Application: gvSIG desktop

package org.gvsig.fmap.data.feature.impl.commands;

import java.util.ArrayList;

import java.util.List;

import java.util.Stack;

import org.gvsig.fmap.data.feature.Command;

import org.gvsig.fmap.data.feature.CommandsRecord;

import org.gvsig.fmap.data.feature.impl.commands.implementation.FeatureCommand;

import org.gvsig.tools.observer.DefaultObservable;

import org.gvsig.tools.observer.Observer;

/**

 * Clase en memoria para registrar y gestionar los comandos que vamos

 * realizando. La forma en que ha sido implementada esta clase, en vez de una

 * ?nica lista para albergar los comandos de deshacer(undos) y los de

 * rehacer(redos), se ha optado por dos pilas una para deshacer(undos) y otra

 * para rehacer(redos), de esta forma :  Cuando se a?ade un nuevo comando, se

 * inserta este a la pila de deshacer(undos) y se borra de la de

 * rehacer(redos). Si se realiza un deshacer se desapila este comando de la

 * pila deshacer(undos) y se apila en la de rehacer(redos). Y de la misma

 * forma cuando se realiza un rehacer se desapila este comando de la pila de

 * rehacer(redos) y pasa a la de deshacer(undos).

 *

 * @author Vicente Caballero Navarro

 */

public abstract class AbstractCommandsRecord implements CommandsRecord {

        private Stack undos = new Stack();

        private Stack redos = new Stack();

        private boolean refresh=true;

        private int undosCount=0;

        private DefaultObservable observable=new DefaultObservable();

        private boolean complex=false;

        private CommandCollection collection=null;

        public void add(Command command){

                if (complex){

                        collection.add(command);

                }else{

                        undos.add(command);

                        redos.clear();

                        refresh=true;

                        observable.notifyObservers(this,new CommandNotification(command,CommandNotification.ADD));

                }

        }

        public void undo() {

                AbstractCommand command = (AbstractCommand) undos.pop();

                command.undo();

                redos.add(command);

                observable.notifyObservers(this,new CommandNotification(command,CommandNotification.UNDO));

        }

        public void redo() {

                AbstractCommand command = (AbstractCommand) redos.pop();

                command.redo();

                undos.add(command);

                observable.notifyObservers(this,new CommandNotification(command,CommandNotification.REDO));

        }

        public boolean moreUndoCommands() {

                return (!undos.isEmpty());

        }

        public boolean moreRedoCommands() {

                return (!redos.isEmpty());

        }

        public List getUndoCommands(){

                Stack clonedUndos=(Stack)undos.clone();

                ArrayList commands=new ArrayList();

                while (!clonedUndos.isEmpty()){

                        commands.add(clonedUndos.pop());

                }

                return commands;

        }

        public List getRedoCommands(){

                Stack clonedRedos=(Stack)redos.clone();

                ArrayList commands=new ArrayList();

                while (!clonedRedos.isEmpty()){

                        commands.add(clonedRedos.pop());

                }

                return commands;

        }

        public int getPointer(){

                if (refresh){

                        undosCount=undos.size()-1;

                }

                return undosCount;

        }

        public void setPointer(int newpos){

                int pos=getPointer();

                if (newpos>pos){

                        for (int i=pos;i<newpos;i++){

                                redo();

                                System.out.println("redos = "+i);

                        }

                }else if (pos>newpos){

                        for (int i=pos-1;i>=newpos;i--){

                                undo();

                                System.out.println("undos = "+i);

                        }

                }

        }

        public int size() {

                return undos.size()+redos.size();

        }

        public void clear() {

                redos.clear();

                undos.clear();

        }

        public Command getNextUndoCommand() {

                return (Command)undos.peek();

        }

        public Command getNextRedoCommand() {

                return (Command)redos.peek();

        }

        public void addObserver(Observer o) {

                observable.addObserver(o);

        }

        public void deleteObserver(Observer o) {

                observable.deleteObserver(o);

        }

        public void deleteObservers() {

                observable.deleteObservers();

        }

        public List getCommandsFeatureDeleted() { // List of Feature

                Stack clonedUndos=(Stack)undos.clone();

                ArrayList commands=new ArrayList();

                while (!clonedUndos.isEmpty()){

                        Command command=(Command)clonedUndos.pop();

                        if (command.getType().equals(Command.DELETE) && command instanceof FeatureCommand) {

                                commands.add(command);

                        }

                }

                return commands;

        }

        public List getCommandsFeatureUpdated() { // List of Feature

                Stack clonedUndos=(Stack)undos.clone();

                ArrayList commands=new ArrayList();

                while (!clonedUndos.isEmpty()){

                        Command command=(Command)clonedUndos.pop();

                        if (command.getType().equals(Command.UPDATE) && command instanceof FeatureCommand) {

                                commands.add(command);

                        }

                }

                return commands;

        }

        public List getCommandsFeatureInserted() { // List of Feature

                Stack clonedUndos=(Stack)undos.clone();

                ArrayList commands=new ArrayList();

                while (!clonedUndos.isEmpty()){

                        Command command=(Command)clonedUndos.pop();

                        if (command.getType().equals(Command.INSERT) && command instanceof FeatureCommand) {

                                commands.add(command);

                        }

                }

                return commands;

        }

        public void endComplex(String description) {

                if (collection.isEmpty()) {

                complex = false;

                return;

        }

                complex=false;

                collection.setDescription(description);

                undos.add(collection);

                redos.clear();

                refresh=true;

                observable.notifyObservers(this,new CommandNotification(collection,CommandNotification.ADD));

        }

        public void startComplex() {

                collection=new CommandCollection();

                complex=true;

        }

        public abstract void delete(Object obj);

        public abstract void insert(Object obj);

        public abstract void update(Object obj, Object oldObj);

}