Application: gvSIG desktop » gvSIG Document Layout

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

 *

 */

package org.gvsig.app.project.documents.layout;

import java.awt.geom.AffineTransform;

import java.lang.reflect.Array;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import org.gvsig.andami.PluginServices;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.layout.commands.FrameCommandsRecord;

import org.gvsig.app.project.documents.layout.commands.FrameManager;

import org.gvsig.app.project.documents.layout.fframes.FFrame;

import org.gvsig.app.project.documents.layout.fframes.FFrameGroup;

import org.gvsig.app.project.documents.layout.fframes.IFFrame;

import org.gvsig.app.project.documents.layout.fframes.IFFrameUseFMap;

import org.gvsig.app.project.documents.layout.toc.TocModelObserver;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Model of LayoutControl.

 *

 * @author Vicente Caballero Navarro

 */

public class DefaultLayoutContext implements LayoutContext {

    public static final String PERSISTENCE_DEFINITION_NAME = "LayoutContext";

    private static final String ISADJUSTINGTOGRID_FIELD = "isAdjustingToGrid";

    private static final String IS_GRID_VISIBLE = "IS_GRID_VISIBLE";

    private static final String IS_RULER_VISIBLE = "IS_RULER_VISIBLE";

    private static final String ISEDITABLE_FIELD = "isEditable";

    /**

     * True when the document window has been opened at least once, false otherwise. This is required

     * to decide whether the page setting dialog has to be shown to the user, otherwise it would be

     * shown every time the document is opened from project persistence

     */

    private static final String HAS_WINDOW_BEEN_EVER_OPEN_FIELD = "hasDocBeenOpened";

    private static final String NUMBEHIND_FIELD = "numBehind";

    private static final String NUMBEFORE_FIELD = "numBefore";

    private static final String ATTRIBUTES_FIELD = "attributes";

    private static final String FFRAMES_FIELD = "fframes";

    private static DefaultLayoutManager layoutManager = null;

    private Attributes m_attributes = null;

    private IFFrame[] fframes;

    private FrameCommandsRecord fcr;

    private static Hashtable nums = new Hashtable();

    private int numBefore = 0;

    private int numBehind = 0;

    private boolean isEditable = true;

    private Boolean adjustToGrid = null;

    private boolean hasDocBeenOpened = false;

    private Boolean m_showRuler;

    private Boolean isGridVisible = null;

    private AffineTransform m_MatrizTransf;

    private ObservableHelper observers;

    private CustomizableObserverHelper tocObservers = new CustomizableObserverHelper() {

                @Override

                protected void doNotify(Object listener, Object data) {

                        TocModelObserver l = (TocModelObserver) listener;

                        l.tocUpdated(DefaultLayoutContext.this, (TocModelChangedNotification) data);

                }

        };

        private MapContext tocModel = null;

    /**

     * Create a new object of LayoutContext.

     */

    public DefaultLayoutContext() {

        layoutManager =

            (DefaultLayoutManager) ProjectManager.getInstance()

                .getDocumentManager(DefaultLayoutManager.TYPENAME);

        observers = new ObservableHelper();

        m_attributes = new Attributes();

        m_MatrizTransf = new AffineTransform();

        m_MatrizTransf.setToIdentity();

        FrameManager fm = new FrameManager();

        fcr = new FrameCommandsRecord(fm);

        updateFFrames();

    }

    public AffineTransform getAT() {

        return m_MatrizTransf;

    }

    public Attributes getAttributes() {

        return m_attributes;

    }

    public void setAtributes(Attributes attributes) {

        m_attributes = attributes;

    }

    public IFFrame[] getFFrames() {

        return fframes;

    }

    public IFFrame getFFrame(int i) {

        return fframes[i];

    }

    public void updateFFrames() {

        ArrayList frames = new ArrayList();

        IFFrame[] auxfframes = fcr.getFrameManager().getFFrames();

        for (int j = numBehind; j <= numBefore; j++) {

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

                if (auxfframes[i].getLevel() == j) {

                    frames.add(auxfframes[i]);

                    continue;

                }

            }

        }

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

    }

    public void delFFrameSelected() {

        fcr.startComplex(PluginServices.getText(this, "remove_elements"));

        IFFrame[] validFrames = fcr.getFrameManager().getFFrames();

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

            IFFrame fframe = validFrames[i];

            if (fframe.isSelected()) {

                fframe.setSelected(false);

                fcr.delete(fframe);

            }

        }

        fcr.endComplex();

        updateFFrames();

    }

    public void clearSelection() {

        for (int i = fcr.getFrameManager().getAllFFrames().length - 1; i >= 0; i--) {

            IFFrame fframe = fcr.getFrameManager().getFFrame(i);

            if (fframe.getSelected() != IFFrame.NOSELECT) {

                fframe.setSelected(false);

            }

        }

    }

    public void delFFrame(int index) {

            IFFrame frame = getFFrame(index);

            delFFrame(frame);

    }

    public void delFFrame(IFFrame frame) {

        for (int i = 0; i < fcr.getFrameManager().getAllFFrames().length; i++) {

            if (fcr.getFrameManager().getFFrame(i).equals(frame)) {

                    frame.setSelected(false);

                fcr.delete(frame);

            }

        }

        updateFFrames();

    }

    public FrameCommandsRecord getFrameCommandsRecord() {

        return fcr;

    }

    public void addFFrame(IFFrame frame, boolean clearSelection, boolean select) {

            frame.setLayoutContext(this);

        IFFrame[] fframes = getFFrames();

        if (clearSelection) {

            for (int i = fframes.length - 1; i >= 0; i--) {

                IFFrame fframe1 = fframes[i];

                fframe1.setSelected(false);

            }

        }

        if (nums.containsKey(frame.getClass())) {

            nums.put(

                frame.getClass(),

                new Integer(Integer.parseInt(nums.get(frame.getClass())

                    .toString()) + 1));

        } else {

            nums.put(frame.getClass(), new Integer(0));

        }

        frame.setNum(Integer.parseInt(nums.get(frame.getClass()).toString()));

        fcr.insert(frame);

        frame.setSelected(select);

        frame.setLevel(getNumBefore());

        updateFFrames();

    }

    public void addFFrameSameProperties(IFFrame frame) {

        fcr.insert(frame);

        frame.setSelected(true);

        frame.setLevel(getNumBefore());

        updateFFrames();

    }

    public int getNumBehind() {

        return --numBehind;

    }

    public int getNumBefore() {

        return ++numBefore;

    }

    public IFFrame[] getAllFFrames() {

        List all = new ArrayList();

        return (IFFrame[]) allFFrames(getFFrames(), all)

            .toArray(new IFFrame[0]);

    }

    public Iterator deepiterator() {

        List all = new ArrayList();

        allFFrames(getFFrames(), all);

        return all.iterator();

    }

    public Iterator iterator() {

        return Arrays.asList(fframes).iterator();

    }

    private List allFFrames(IFFrame[] fframes, List all) {

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

            if (fframes[i] instanceof FFrameGroup) {

                List groupFrames =

                    allFFrames(((FFrameGroup) fframes[i]).getFFrames(), all);

                if (!all.containsAll(groupFrames)) {

                    all.addAll(groupFrames);

                }

            } else {

                if (!all.contains(fframes[i])) {

                    all.add(fframes[i]);

                }

            }

        }

        return all;

    }

    public IFFrame[] getSelectedFFrames() {

        ArrayList selecList = new ArrayList();

        IFFrame[] fframes = getFFrames();

        for (int i = fframes.length - 1; i >= 0; i--) {

            IFFrame fframe = fframes[i];

            if (fframe.getSelected() != IFFrame.NOSELECT) {

                selecList.add(fframe);

            }

        }

        return (IFFrame[]) selecList.toArray(new IFFrame[selecList.size()]);

    }

        public <T> T[] getSelectedFFrames(Class<T> clazz) {

        ArrayList<T> selecList = new ArrayList<T>();

        IFFrame[] fframes = getFFrames();

        for (int i = fframes.length - 1; i >= 0; i--) {

                IFFrame fframe = fframes[i];

                if (clazz.isInstance(fframe)) {

                if (fframe.getSelected() != IFFrame.NOSELECT) {

                    selecList.add((T)fframe);

                }

                }

        }

        T[] newInstance = (T[])Array.newInstance(clazz, selecList.size());

                return selecList.toArray(newInstance);

        }

    public boolean isEditable() {

        return isEditable;

    }

    public void setEditable(boolean b) {

        if (!b) {

            clearSelection();

            // layoutControl.setTool("layoutzoomin");

            PluginServices.getMainFrame().setSelectedTool("ZOOM_IN");

        }

        isEditable = b;

    }

    public boolean isAdjustingToGrid() {

        if (adjustToGrid == null) {

            adjustToGrid = new Boolean(layoutManager.getDefaultAdjustToGrid());

        }

        return adjustToGrid.booleanValue();

    }

    public void setAdjustToGrid(boolean b) {

        adjustToGrid = new Boolean(b);

    }

    public void setRuler(boolean b) {

        m_showRuler = new Boolean(b);

    }

    public boolean getRuler() {

        if (m_showRuler == null) {

            m_showRuler = new Boolean(layoutManager.getDefaultShowRulers());

        }

        return m_showRuler.booleanValue();

    }

    public boolean isGridVisible() {

        if (isGridVisible == null) {

            isGridVisible = new Boolean(layoutManager.getDefaultShowGrid());

        }

        return isGridVisible.booleanValue();

    }

    public void setGridVisible(boolean b) {

        isGridVisible = new Boolean(b);

    }

    public void fullRefresh() {

        IFFrame[] fframes = getFFrames();

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

            if (fframes[i] instanceof IFFrameUseFMap) {

                IFFrameUseFMap fframe = (IFFrameUseFMap) fframes[i];

                fframe.refresh();

            }

        }

        notifAllObservers();

    }

    public void notifAllObservers(){

        observers.notifyObservers(this,

            new DefaultLayoutNotification(LayoutNotification.LAYOUT_REFRESH));

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(DefaultLayoutContext.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "Layout context persistence definition", null, null);

            definition.addDynFieldInt(NUMBEHIND_FIELD).setMandatory(true);

            definition.addDynFieldInt(NUMBEFORE_FIELD).setMandatory(true);

            definition.addDynFieldObject(ATTRIBUTES_FIELD)

                .setClassOfValue(Attributes.class).setMandatory(true);

            definition.addDynFieldArray(FFRAMES_FIELD)

                .setClassOfItems(IFFrame.class).setMandatory(true);

            // ==================

            definition.addDynFieldBoolean(ISADJUSTINGTOGRID_FIELD).setMandatory(true);

            definition.addDynFieldBoolean(ISEDITABLE_FIELD).setMandatory(true);

            definition.addDynFieldBoolean(IS_GRID_VISIBLE).setMandatory(false);

            definition.addDynFieldBoolean(IS_RULER_VISIBLE).setMandatory(false);

            definition.addDynFieldBoolean(HAS_WINDOW_BEEN_EVER_OPEN_FIELD).setMandatory(false);

        }

        FFrame.registerPersistent();

        Attributes.registerPersistent();

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        adjustToGrid = state.getBoolean(ISADJUSTINGTOGRID_FIELD);

        isEditable = state.getBoolean(ISEDITABLE_FIELD);

        if (state.hasValue(IS_GRID_VISIBLE)) {

            isGridVisible = state.getBoolean(IS_GRID_VISIBLE);

        }

        if (state.hasValue(IS_RULER_VISIBLE)) {

            m_showRuler = state.getBoolean(IS_RULER_VISIBLE);

        }

        if (state.hasValue(HAS_WINDOW_BEEN_EVER_OPEN_FIELD)) {

                setHasDocBeenOpened(state.getBoolean(HAS_WINDOW_BEEN_EVER_OPEN_FIELD));

        }

        else {

                // if not present, assume it was opened (as we are loading from persistence)

                setHasDocBeenOpened(true);

        }

        numBehind = state.getInt(NUMBEHIND_FIELD);

        numBefore = state.getInt(NUMBEFORE_FIELD);

        m_attributes = (Attributes) state.get(ATTRIBUTES_FIELD);

        IFFrame[] fframes =

            (IFFrame[]) state.getArray(FFRAMES_FIELD, IFFrame.class);

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

            addFFrame(fframes[i], true, true);

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(ISADJUSTINGTOGRID_FIELD, isAdjustingToGrid());

        state.set(ISEDITABLE_FIELD, isEditable());

        state.set(NUMBEHIND_FIELD, numBehind);

        state.set(NUMBEFORE_FIELD, numBefore);

        state.set(ATTRIBUTES_FIELD, m_attributes);

        state.set(FFRAMES_FIELD, fframes);

        state.set(HAS_WINDOW_BEEN_EVER_OPEN_FIELD, new Boolean(hasDocBeenOpened()));

        state.set(IS_RULER_VISIBLE, this.getRuler());

        state.set(IS_GRID_VISIBLE, this.isGridVisible());

    }

    public void setNumBefore(int numBefore) {

        this.numBefore = numBefore;

    }

    public void setNumBehind(int numBehind) {

        this.numBehind = numBehind;

    }

    public void addObserver(Observer o) {

        observers.addObserver(o);

    }

    public void deleteObserver(Observer o) {

      observers.deleteObserver(o);

    }

    public void deleteObservers() {

       observers.deleteObservers();

    }

        public void setTocModel(MapContext tocModel) {

                MapContext oldModel = this.tocModel;

                this.tocModel = tocModel;

                if (tocModel==oldModel){

                        // no real change

                        return;

                }

                else {

                    tocObservers.notifyObservers(this,

                        new TocModelChangedImpl(TocModelChangedNotification.Type.MODEL_SET, tocModel));

                }

        }

        public void notifyTocUpdated(TocModelChangedNotification.Type type) {

            tocObservers.notifyObservers(this,

                            new TocModelChangedImpl(type, tocModel));

        }

        public MapContext getTocModel() {

                return this.tocModel;

        }

        public void addTocObserver(TocModelObserver observer) {

                this.tocObservers.addObserver(observer);

        }

        public void removeTocObserver(TocModelObserver observer) {

                this.tocObservers.deleteObserver(observer);

        }

        public void removeTocObservers() {

                this.tocObservers.deleteObservers();

        }

    /**

     * True when the document window has been opened at least once, false otherwise. This is required

     * to decide whether the page setting dialog has to be shown to the user, otherwise it would be

     * shown every time the document is opened from project persistence

     */

        public boolean hasDocBeenOpened() {

                return hasDocBeenOpened;

        }

    /**

     * True when the document window has been opened at least once, false otherwise. This is required

     * to decide whether the page setting dialog has to be shown to the user, otherwise it would be

     * shown every time the document is opened from project persistence

     */

        public void setHasDocBeenOpened(boolean hasBeenOpened) {

                this.hasDocBeenOpened = hasBeenOpened;

        }

}