| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.project.documents.layout.commands;

import java.awt.Image;

import java.util.ArrayList;

import java.util.BitSet;

import org.gvsig.data.commands.AbstractCommand;

import org.gvsig.data.commands.Command;

import org.gvsig.data.commands.CommandsRecord;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.project.documents.layout.fframes.FFrameGroup;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame;

import com.iver.cit.gvsig.project.documents.layout.fframes.IFFrameViewDependence;

/**

 * Class responsible for the edition of the FFrames.

 *

 * @author Vicente Caballero Navarro

 */

public class DefaultEditableFeatureSource implements EditableFeatureSource {

    private ArrayList<IFFrame> fframes = new ArrayList<IFFrame>();

    private CommandsRecord cr;

    private BitSet invalidates = new BitSet();

    private boolean complex = false;

    private int numAdd = 0;

    public DefaultEditableFeatureSource() {

        this.cr = new FrameCommandsRecord();

    }

    /**

     * Returns from an index the FFrame.

     *

     * @param index

     *

     * @return FFrame.

     */

    public IFFrame getFFrame(int index) {

        return fframes.get(index);

    }

    /**

     * Returns the number of FFrame.

     *

     * @return Number of FFrames

     */

    public int getFFrameCount() {

        return fframes.size();

    }

    /**

     * Add a FFrame in the mechanism of control creating a command.

     *

     * @param f FFrame to add

     */

    public void addFFrame(IFFrame f) {

        int virtualIndex = doAddFFrame(f);

        AbstractCommand command=new InsertFrameCommand(this, f, virtualIndex);

        command.setDescription(f.getNameFFrame());

        if (complex) {

            commands.add(command);

        } else {

            cr.add(command);

            PluginServices.getMainFrame().enableControls();

        }

    }

    /**

     * Undo the last command added.

     * @throws EditionCommandException

     */

    public void undo() {

        if (moreUndoCommands()) {

           cr.undo();

        }

    }

    /**

     * Redo the last command undid.

     * @throws EditionCommandException

     */

    public void redo() {

        if (moreRedoCommands()) {

           cr.redo();

        }

    }

    /**

     * Returns if there are more commands to undo

     *

     * @return True if there are more commands to undo

     */

    public boolean moreUndoCommands() {

        return cr.moreUndoCommands();

    }

    /**

     * Returns if there are more commands to redo

     *

     * @return True if there are more commands to redo

     */

    public boolean moreRedoCommands() {

        return cr.moreRedoCommands();

    }

    /**

     * Remove the FFrame by the index.

     *

     * @param index

     */

    public void removeFFrame(int index) {

        if (invalidates.get(index)) {

            return;

        }

        IFFrame frame=getFFrame(index);

        doRemoveFFrame(index);

        AbstractCommand command=new DeleteFrameCommand(this, index);

        command.setDescription(frame.getNameFFrame());

        if (complex) {

            commands.add(command);

        } else {

            cr.add(command);

            PluginServices.getMainFrame().enableControls();

        }

    }

    /**

     * Modify a fframe to another fframe new.

     *

     * @param fant Previous Fframe.

     * @param fnew New FFrame.

     */

    public boolean modifyFFrame(IFFrame fant, IFFrame fnew) {

        int posAnt = -1;

        for (int i = 0; i < fframes.size(); i++) {

            if (fframes.get(i).equals(fant) && !invalidates.get(i)) {

                    posAnt = i;

            }

        }

        if (posAnt==-1)

                return false;

        int pos = doModifyFFrame(posAnt, fnew);

        AbstractCommand command=new UpdateFrameCommand(this, fnew, posAnt, pos);

        command.setDescription(fant.getNameFFrame());

        if (complex) {

            commands.add(command);

        } else {

            cr.add(command);

            PluginServices.getMainFrame().enableControls();

        }

        refreshDependences(fant, fnew);

        return true;

    }

    public void setImage(Image i) {

        // TODO Auto-generated method stub

    }

    public Image getImage() {

        // TODO Auto-generated method stub

        return null;

    }

    /**

     * Start a composed command of other simpler commands.

     * Create an only one command to reproduce if all at once.

     */

    public void startComplexCommand() {

        complex = true;

        commands = new CommandCollection();

    }

    /**

     * Terminate a composed command.

     */

    public void endComplexCommand(String description) {

        if (commands.isEmpty()) {

                complex = false;

                return;

        }

            commands.setDescription(description);

            cr.pushCommand(commands);

        complex = false;

        PluginServices.getMainFrame().enableControls();

    }

    /**

     * Undo add FFrame from index.

     *

     * @param index

     */

    public void undoAddFFrame(int index) {

        doRemoveFFrame(index);

        numAdd--;

    }

    /**

     * Add FFrame.

     *

     * @param frame

     *

     * @return index of new fframe.

     */

    public int doAddFFrame(IFFrame frame) {

        fframes.add(frame);

        numAdd++;

        return fframes.size() - 1;

    }

    /**

     * Add FFrame from index.

     *

     * @param frame New FFrame.

     * @param index Index of new FFrame.

     */

    public void doAddFFrame(IFFrame frame, int index) {

        invalidates.set(index, false);

        fframes.set(index, frame);

        numAdd++;

    }

    /**

     * Undo modify an FFrame modified.

     *

     * @param fant Previous fframe.

     * @param fnew New FFrame.

     * @param indexAnt Actual index.

     * @param indexLast Previous index.

     */

    public void undoModifyFFrame(int index,

        int newIndex) {

            undoRemoveFFrame(index);

                undoAddFFrame(newIndex);

                IFFrame fant=fframes.get(newIndex);

                IFFrame fnew=fframes.get(index);

                refreshDependences(fant,fnew);

    }

    /**

     * Modify FFrame from index and new FFrame.

     *

     * @param indexAnt Actual index.

     * @param frameNext New FFrame.

     *

     * @return New index of FFrame.

     */

    public int doModifyFFrame(int indexAnt, IFFrame frameNext) {

        doRemoveFFrame(indexAnt);

        return doAddFFrame(frameNext);

    }

    /**

     * Undo Remove FFrame from index.

     *

     * @param index Actual index of FFrame.

     */

    public void undoRemoveFFrame(int index) {

        invalidates.set(index, false);

    }

    /**

     * Remove FFrame from actual index.

     *

     * @param index Actual index.

     */

    public void doRemoveFFrame(int index) {

        invalidates.set(index, true);

    }

    /**

     * Returns all the fframes that are not removed.

     *

     * @return Vector with fframes.

     */

    public IFFrame[] getFFrames() {

        ArrayList<IFFrame> frames = new ArrayList<IFFrame>();

        for (int i = 0; i < getFFrameCount(); i++) {

            if (!invalidates.get(i)) {

                frames.add(fframes.get(i));

            }

        }

        IFFrame[] fframesV = frames.toArray(new IFFrame[0]);

        return fframesV;

    }

    /**

     * Returns all the fframes, remove and done not remove.

     *

     * @return All FFrames.

     */

    public IFFrame[] getAllFFrames() {

        return fframes.toArray(new IFFrame[0]);

    }

    /**

     * Returns all the fframes, remove and done not remove and the ones that are in the FFrameGroups

     *

     * @return All FFrames.

     */

    public IFFrame[] getAllFFrameToDepends() {

        IFFrame[] fs = getAllFFrames();

        return getFFrameToDepends(fs);

    }

    private IFFrame[] getFFrameToDepends(IFFrame[] fs) {

        ArrayList<IFFrame> result = new ArrayList<IFFrame>();

        for (int i = 0; i < fs.length; i++) {

            result.add(fs[i]);

            if (fs[i] instanceof FFrameGroup) {

                IFFrame[] ffs = getFFrameToDepends(((FFrameGroup) fs[i]).getFFrames());

                for (int j = 0; j < ffs.length; j++) {

                    result.add(ffs[j]);

                }

            }

        }

        return result.toArray(new IFFrame[0]);

    }

    private void refreshDependences(IFFrame fant, IFFrame fnew) {

        for (int i = 0; i < fframes.size(); i++) {

            if (fframes.get(i) instanceof IFFrameViewDependence) {

                IFFrameViewDependence f = (IFFrameViewDependence) fframes.get(i);

                f.refreshDependence(fant, fnew);

            }

        }

    }

    /**

     * Returns the command record.

     *

     * @return CommandRecord.

     */

    public CommandsRecord getCommandRecord() {

        return cr;

    }

        public void redoModifyFFrame(int index, int newIndex, IFFrame frame) {

                doRemoveFFrame(index);

                doAddFFrame(frame,newIndex);

                IFFrame fant=fframes.get(newIndex);

                refreshDependences(fant,frame);

        }

}