| gvSIG desktop 1

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

import java.util.ArrayList;

import java.util.List;

import java.util.Stack;

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureStore;

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

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.WeakReferencingObservable;

import org.gvsig.tools.observer.impl.DelegateWeakReferencingObservable;

/**

 * 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, WeakReferencingObservable{

        private Stack undos = new Stack();

        private Stack redos = new Stack();

        private boolean refresh=true;

        private int undosCount=0;

        private DelegateWeakReferencingObservable delegateObservable = new DelegateWeakReferencingObservable(this);

        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;

                        delegateObservable.notifyObservers(new DefaultCommandNotification(command,

                    CommandNotification.ADD));

                }

        }

        public void undo() throws DataException {

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

                command.undo();

                redos.add(command);

                delegateObservable.notifyObservers(new DefaultCommandNotification(command,

                CommandNotification.UNDO));

        }

        public void redo() throws DataException {

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

                command.redo();

                undos.add(command);

                delegateObservable.notifyObservers(new DefaultCommandNotification(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) throws DataException {

                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) {

                delegateObservable.addObserver(o);

        }

        public void deleteObserver(Observer o) {

                delegateObservable.deleteObserver(o);

        }

        public void deleteObservers() {

                delegateObservable.deleteObservers();

        }

/**

 * @deprecated

 * @return

 */

        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;

        }

        /**

         * @deprecated

         * @return

         */

        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;

        }

        /**

         * @deprecated

         * @return

         */

        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() {

                if (collection.isEmpty()) {

                complex = false;

                return;

        }

                complex=false;

                undos.add(collection);

                redos.clear();

                refresh=true;

                delegateObservable.notifyObservers(new DefaultCommandNotification(collection,

                CommandNotification.ADD));

        }

        public void startComplex(String description) {

                collection=new CommandCollection(description);

                complex=true;

        }

        public abstract void delete(Object obj);

        public abstract void insert(Object obj);

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

        public abstract void select(

                        FeatureReferenceSelection selection,

                        FeatureReference reference);

        public abstract void deselect(

                        FeatureReferenceSelection selection,

                        FeatureReference reference);

        public abstract void selectAll(

                        FeatureReferenceSelection selection)

            throws DataException;

        public abstract void deselectAll(

                        FeatureReferenceSelection selection)

            throws DataException;

        public abstract void selectionReverse(

                        FeatureReferenceSelection selection);

        public abstract void selectionSet(DefaultFeatureStore store,

                        FeatureReferenceSelection oldSelection,

                        FeatureReferenceSelection newSelection);

}