CommandStore.java

/**********************************************
 * Copyright (C) 2011 Lukas Laag
 * This file is part of svgreal.
 * 
 * svgreal 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 3 of the License, or
 * (at your option) any later version.
 * 
 * svgreal 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 svgreal.  If not, see http://www.gnu.org/licenses/
 **********************************************/
package org.vectomatic.svg.edit.client.command;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.vectomatic.svg.edit.client.SvgrealApp;

import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.google.gwt.core.client.GWT;

/**
 * Class to represent the stack of commands which have
 * been applied to an SVG model to edit it.
 */
public class CommandStore extends ListStore<BeanModel> {
	/**
	 * The current command index
	 * Can vary between 0 and N where N is the number of commands
	 * in the stack. 0 means before the least recent command (redo
	 * is possible, undo is impossible). N means after the most recent
	 * command (redo is impossible, undo is possible)
	 */
	private int current;
	
	public CommandStore() {
		super();
		applyFilters(null);
	}
	
	/**
	 * Returns true if the command stack contains a command which can be 
	 * undone false otherwise.
	 * @return true if the command stack contains a command which can be 
	 * undone false otherwise.
	 */
	public boolean canUndo() {
		return (current > 0);
	}
	
	/**
	 * Returns true if the command stack contains a command which can be 
	 * redone false otherwise.
	 * @return true if the command stack contains a command which can be 
	 * redone false otherwise.
	 */
	public boolean canRedo() {
		return (current < snapshot.size());
	}
	
	/**
	 * Undoes the current command
	 */
	public void undo() {
		if (!canUndo()) {
			throw new IllegalStateException("Invalid undo");
		}
		SvgrealApp.getApp().getCommandFactorySelector().suspendAll();
		((ICommand)getUndoCommand().getBean()).rollback();
		current--;
		applyFilters(null);
		SvgrealApp.getApp().getCommandFactorySelector().resumeAll();
	}
	
	/**
	 * Undoes all the commands up to the specified command
	 */
	public void undo(BeanModel command) {
		if (!canUndo()) {
			throw new IllegalStateException("Invalid undo");
		}
		SvgrealApp.getApp().getCommandFactorySelector().suspendAll();
		boolean found = false;
		for (int i = 0; i < current; i++) {
			if (all.get(i) == command) {
				found = true;
				break;
			}
		}
		if (!found) {
			throw new IllegalStateException("Invalid undo");
		}
		
		BeanModel currentCommand;
		do {
			currentCommand = getUndoCommand();
			((ICommand)currentCommand.getBean()).rollback();
			current--;
		} while(currentCommand != command);
		
		applyFilters(null);
		SvgrealApp.getApp().getCommandFactorySelector().resumeAll();
	}

	
	/**
	 * Redoes the previously undone command
	 */
	public void redo() {
		if (!canRedo()) {
			throw new IllegalStateException("Invalid redo");
		}
		SvgrealApp.getApp().getCommandFactorySelector().suspendAll();
		((ICommand)getRedoCommand().getBean()).commit();
		current++;
		applyFilters(null);
		SvgrealApp.getApp().getCommandFactorySelector().resumeAll();
	}

	/**
	 * Redoes the previously undone command up to the specified command
	 */
	public void redo(BeanModel command) {
		if (!canRedo()) {
			throw new IllegalStateException("Invalid redo");
		}
		SvgrealApp.getApp().getCommandFactorySelector().suspendAll();
		boolean found = false;
		for (int i = current, size = snapshot.size(); i < size; i++) {
			if (snapshot.get(i) == command) {
				found = true;
				break;
			}
		}
		if (!found) {
			throw new IllegalStateException("Invalid redo");
		}
		BeanModel currentCommand;
		do {
			currentCommand = getRedoCommand();
			((ICommand)currentCommand.getBean()).commit();
			current++;
		} while(currentCommand != command);
		applyFilters(null);
		SvgrealApp.getApp().getCommandFactorySelector().resumeAll();
	}

	/**
	 * Returns the command which will be undone if undo is invoked
	 * @return
	 */
	public BeanModel getUndoCommand() {
		if (!canUndo()) {
			return null;
		}
		return snapshot.get(current - 1);
	}
	
	/**
	 * Returns the command which will be redone if undo is invoked
	 * @return
	 */
	public BeanModel getRedoCommand() {
		if (!canRedo()) {
			return null;
		}
		return snapshot.get(current);
	}
	
	/**
	 * Gets all the commands currently in the stack
	 * @return
	 */
	public List<BeanModel> getCommands() {
		return all;
	}
	
	/**
	 * Gets all the commands which can be undone
	 * @return
	 */
	public List<BeanModel> getUndoCommands() {
		if (!canUndo()) {
			return null;
		}
		return snapshot.subList(0, current);
	}

	/**
	 * Gets all the commands which can be redone
	 * @return
	 */
	public List<BeanModel> getRedoCommands() {
		if (!canRedo()) {
			return null;
		}
		return snapshot.subList(current, snapshot.size());
	}

	/**
	 * Adds a new command to the stack
	 * @param command the command to add
	 */
	public void addCommand(ICommand command) {
		GWT.log("CommandStore.addCommand: " + command.getDescription());
		if (current < snapshot.size()) {
			for (int i = snapshot.size() - 1; i >= current; i--) {
				snapshot.remove(i);
			}
		}
        StoreEvent<BeanModel> evt = createStoreEvent();
        BeanModel commandModel = command.asModel();
        List<BeanModel> commandList = Collections.<BeanModel>singletonList(commandModel);
        evt.setModels(commandList);
        if (!fireEvent(BeforeAdd, evt)) {
          return;
        }
        snapshot.add(commandModel);
        all.add(commandModel);
		current = snapshot.size();
        evt = createStoreEvent();
        evt.setModels(commandList);
        evt.setIndex(current - 1);
        fireEvent(Add, evt);
	}	

	@Override
	public void applyFilters(String property) {
	    filterProperty = property;
	    if (!filtersEnabled) {
	    	snapshot = all;
		    filtersEnabled = true;
	    }
		all = filtered = new ArrayList<BeanModel>(snapshot.subList(0, current));
		fireEvent(Filter, createStoreEvent());
	}
	
	@Override
	public void clearFilters() {
		// Filters cannot be cleared as they are part of the
		// way this class work.
	}
}