Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.task.impl;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class BaseTaskStatus implements SimpleTaskStatus {

    private static final Logger LOG = LoggerFactory

            .getLogger(BaseTaskStatus.class);

    protected class SubtaskValues {

        long minValue = 0;

        long maxValue = 0;

        long curValue = 0;

        String message = null;

        @Override

        public Object clone() throws CloneNotSupportedException {

            SubtaskValues other = new SubtaskValues();

            other.curValue = this.curValue;

            other.maxValue = this.maxValue;

            other.minValue = this.minValue;

            other.message = this.message;

            return other;

        }

    }

    protected Date lastModification = null;

    protected SubtaskValues values;

    protected List subtaskStack = null;

    protected String title = null;

    protected String code = null;

    protected boolean isCancelled = false;

    protected boolean isAbortedByError = false;

    protected boolean isRunning = true;

    protected TaskStatusManager manager = null;

    protected boolean isCancellable;

    protected boolean isCancellationRequested;

    protected ObservableHelper observers = null;

    protected boolean autoremove;

    private long startMillis;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public BaseTaskStatus(String title) {

        this.manager = ToolsLocator.getTaskStatusManager();

        this.autoremove = true;

        this.title = title;

        this.values = new SubtaskValues();

        this.isCancelled = false;

        this.isAbortedByError = false;

        this.isRunning = true;

        this.isCancellable = false;

        this.isCancellationRequested = false;

        this.code = this.manager.getNewCode();

        this.observers = new ObservableHelper();

        this.touch();

    }

    public BaseTaskStatus(String tittle, long minValue, long maxValue) {

        this(tittle);

        this.values.minValue = minValue;

        this.values.maxValue = maxValue;

    }

    @Override

    public void restart() {

        this.autoremove = true;

        this.values = new SubtaskValues();

        this.isCancelled = false;

        this.isAbortedByError = false;

        this.isRunning = true;

        this.isCancellable = false;

        this.isCancellationRequested = false;

        this.touch();

    }

    @Override

    public void setRangeOfValues(long min, long max) {

        this.values.minValue = min;

        this.values.maxValue = max;

    }

    protected void touch() {

        touch(true);

    }

    protected void touch(boolean clearmsg) {

        Date now = new Date();

        if (clearmsg) {

            if (this.lastModification != null && (now.getTime() - this.lastModification.getTime()) > 4000) {

                this.values.message = null;

            }

        }

        this.lastModification = now;

        this.notifyObservers();

    }

    protected void notifyObservers() {

        this.manager.update(this);

        this.observers.notifyObservers(this, null);

    }

    @Override

    public Date getLastModification() {

        return this.lastModification;

    }

    @Override

    public void message(String message) {

        this.values.message = message;

        this.touch(false);

    }

    @Override

    public String getTitle() {

        return this.title;

    }

    @Override

    public String getCode() {

        return this.code;

    }

    @Override

    public void setCurValue(long value) {

        //LOG.debug("setCurValue: '"+value+"'.");

        this.values.curValue = value;

        this.touch(false);

    }

    @Override

    public void incrementCurrentValue() {

        this.values.curValue++;

        this.touch(false);

    }

    @Override

    public int getCompleted() {

        if (!this.isRunning) {

            return 100;

        }

        if (this.values.maxValue == this.values.minValue) {

            // No se puede calcular ya que no se ha indicado el numero de elementos

            // sobre los que se esta trabajando, asi que devoobemos el 100%.

            return 100;

        }

        try {

            return (int) (((this.values.curValue - this.values.minValue) * 100) / (this.values.maxValue - this.values.minValue));

        } catch (Exception e) {

            return 100;

        }

    }

    @Override

    public String getLabel() {

        String progress;

        if (this.values.maxValue == this.values.minValue) {

            // No se puede calcular ya que no se ha indicado el numero de elementos

            // sobre los que se esta trabajando.

            if (this.values.curValue > 0) {

                progress = " (" + this.values.curValue + ")";

            } else {

                progress = "";

            }

        } else {

            progress = " (" + (this.values.curValue - this.values.minValue) + " / " + (this.values.maxValue - this.values.minValue) + ")";

        }

        if (this.values.message == null) {

            return progress;

        } else {

            return this.values.message + progress;

        }

    }

    public String getMessage() {

        return this.values.message;

    }

    @Override

    public void terminate() {

        if (!isRunning) {

            return;

        }

        this.isRunning = false;

        if (LOG.isDebugEnabled()) {

            long endMillis = System.currentTimeMillis();

            LOG.debug("Terminated status {} execution in {} ms", getTitle(), endMillis - startMillis);

        }

        this.touch();

        if (this.autoremove) {

            this.remove();

        }

    }

    @Override

    public void cancel() {

        if (!isRunning) {

            return;

        }

        this.isCancelled = true;

        this.isRunning = false;

        this.touch();

        if (this.autoremove) {

            this.remove();

        }

    }

    @Override

    public void abort() {

        if (!isRunning) {

            return;

        }

        this.isAbortedByError = true;

        this.isRunning = false;

        this.touch(false);

        if (this.autoremove) {

            this.remove();

        }

    }

    @Override

    public boolean isCancelled() {

        return this.isCancelled;

    }

    @Override

    public boolean isAborted() {

        return this.isAbortedByError;

    }

    @Override

    public boolean isRunning() {

        return this.isRunning;

    }

    @Override

    public TaskStatusManager getManager() {

        return this.manager;

    }

    @Override

    public boolean isIndeterminate() {

        return this.values.maxValue <= this.values.minValue;

    }

    @Override

    public void add() {

        this.manager.add(this);

        if (LOG.isDebugEnabled()) {

            startMillis = System.currentTimeMillis();

        }

    }

    @Override

    public void remove() {

        if(!this.isRunning() && !this.isAborted() && !this.isCancelled()){

            this.values.message = "";

        }

        this.manager.remove(this);

    }

    @Override

    public boolean isCancellable() {

        return this.isCancellable;

    }

    @Override

    public void setCancellable(boolean cancellable) {

        this.isCancellable = cancellable;

    }

    @Override

    synchronized public boolean isCancellationRequested() {

        return this.isCancellationRequested;

    }

    @Override

    synchronized public void cancelRequest() {

        this.isCancellationRequested = true;

    }

    @Override

    synchronized public void addObserver(Observer o) {

        this.observers.addObserver(o);

    }

    @Override

    synchronized public void deleteObserver(Observer o) {

        this.observers.deleteObserver(o);

    }

    @Override

    synchronized public void deleteObservers() {

        this.observers.deleteObservers();

    }

    @Override

    public void setTittle(String tittle) {

        setTitle(tittle);

    }

    @Override

    public void setTitle(String title) {

        if (this.title != null) {

            return;

        }

        this.title = title;

    }

    @Override

    public void setAutoremove(boolean autoremove) {

        this.autoremove = autoremove;

    }

    @Override

    public boolean getAutoRemove() {

        return this.autoremove;

    }

    @Override

    public void push() {

        if (this.subtaskStack == null) {

            this.subtaskStack = new ArrayList();

        }

        this.subtaskStack.add(0, this.values);

        try {

            this.values = (SubtaskValues) this.values.clone();

        } catch (CloneNotSupportedException ex) {

        }

    }

    @Override

    public void pop() {

        if (this.subtaskStack == null || this.subtaskStack.isEmpty()) {

            return;

        }

        this.values = (SubtaskValues) this.subtaskStack.get(0);

        this.subtaskStack.remove(0);

        touch();

    }

    @Override

    public void setIndeterminate() {

        this.values.maxValue = 0;

        this.values.minValue = 0;

        this.values.curValue = 0;

    }

}