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.text.NumberFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import javax.swing.ImageIcon;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.gui.preferencespage.PreferenceKeys;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.AbstractDocument;

import org.gvsig.app.project.documents.AbstractDocumentManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.actions.CopyDocumentAction;

import org.gvsig.app.project.documents.actions.CutDocumentAction;

import org.gvsig.app.project.documents.actions.PasteDocumentAction;

import org.gvsig.app.project.documents.gui.WindowLayout;

import org.gvsig.app.project.documents.layout.contextmenu.gui.AbstractLayoutContextMenuAction;

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

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

import org.gvsig.app.project.documents.layout.fframes.gui.dialogs.IFFrameDialog;

import org.gvsig.app.project.documents.layout.gui.DefaultLayoutPanel;

import org.gvsig.app.project.documents.layout.gui.LayoutPanel;

import org.gvsig.app.project.documents.layout.gui.MapProperties;

import org.gvsig.app.project.documents.layout.gui.dialogs.FConfigLayoutDialog;

import org.gvsig.app.project.documents.view.IContextMenuAction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.utils.XMLEntity;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Factory of maps.

 *

 * @author Vicente Caballero Navarro

 */

public class DefaultLayoutManager extends AbstractDocumentManager implements

    LayoutManager {

    static final Logger LOG = LoggerFactory

        .getLogger(DefaultLayoutManager.class);

    static final String KEY_LAYOUT_FFRAMEDIALOG =

        "app.project.documents.layout.fframes.gui";

    static final String KEY_LAYOUT_FFRAME =

        "app.project.documents.layout.fframes";

    public static final String PERSISTENCE_LAYOUT_DOCUMENT_DEFINITION_NAME =

        "LayoutDocument";

    private static final String LAYOUT_CONTEXT_MENUS = "Layout_ContextMenus";

    ExtensionPointManager extensionPoints = ToolsLocator

        .getExtensionPointManager();

    private Boolean defaultShowGrid = null;

    private Boolean defaultAdjustToGrid = null;

    private Boolean defaultShowRulers = null;

    private DynStruct persistenceDefinition;

    /**

     * Returns image of button.

     *

     * @return Image button.

     */

    public ImageIcon getIcon() {

            return ToolsSwingLocator.getIconThemeManager().getCurrent().get("document-map-icon");

    }

    /**

     * Returns image of selected button.

     *

     * @return Image button.

     */

    public ImageIcon getIconSelected() {

        return ToolsSwingLocator.getIconThemeManager().getCurrent().get("document-map-icon-sel");

    }

    /**

     * Returns the name of registration in the point of extension.

     *

     * @return Name of registration

     */

    public String getTypeName() {

        return TYPENAME;

    }

    /**

     * Returns the name of ProjectDocument.

     *

     * @return Name of ProjectDocument.

     */

    public String getTitle() {

        return PluginServices.getText(this, "Mapa");

    }

    public AbstractDocument createDocument() {

        return new DefaultLayoutDocument(this);

    }

    public Class getMainWindowClass() {

        return DefaultLayoutPanel.class;

    }

    public IWindow getMainWindow(Document doc, WindowLayout layout) {

        LayoutPanel layoutPanel;

        layoutPanel =

            (LayoutPanel) PluginServices.getMDIManager().getSingletonWindow(

                getMainWindowClass(), doc);

        if (layoutPanel != null) {

            // The layout window document is already created, return it.

            return layoutPanel;

        }

        layoutPanel = (LayoutPanel) this.createDocumentWindow(doc);

        if (layout != null) {

            layoutPanel.setWindowLayout(layout);

        }

        layoutPanel.setLayoutManager(this);

        layoutPanel.getLayoutControl().fullRect();

        layoutPanel.getWindowInfo().setTitle(

            PluginServices.getText(this, "Mapa") + " : "

                + layoutPanel.getName());

        ((AbstractDocument) doc).raiseEventCreateWindow(layoutPanel);

        return layoutPanel;

    }

    public IFFrameDialog createFFrameDialog(IFFrame fframe,

        LayoutPanel layoutPanel, AffineTransform affineTransform) {

        ExtensionPoint ep = extensionPoints.add(KEY_LAYOUT_FFRAMEDIALOG);

        try {

            Object[] args = new Object[2];

            args[0] = layoutPanel;

            args[1] = fframe;

            Object obj = ep.create(fframe.getName(), args);

            if (obj != null) {

                IFFrameDialog fframedialog = (IFFrameDialog) obj;

                fframedialog.setRectangle(fframe

                    .getBoundingBox(affineTransform));

                return fframedialog;

            }

        } catch (Exception e) {

            LOG.error("Error creating a FFrameDialog", e);

        }

        return null;

    }

    public IFFrameDialog createFFrameDialog(IFFrame fframe,

        LayoutPanel layoutPanel) {

        return createFFrameDialog(fframe, layoutPanel, layoutPanel

            .getLayoutControl().getAT());

    }

    public void registerFrameFactory(FrameFactory frameFactory, String alias) {

        ExtensionPoint ep =

            ToolsLocator.getExtensionPointManager().add(KEY_LAYOUT_FFRAME);

        ep.append(frameFactory.getRegisterName(), "", frameFactory);

        if (alias != null) {

            ep.addAlias(frameFactory.getRegisterName(), alias);

        }

    }

    public void registerFrameFactory(FrameFactory frameFactory) {

        registerFrameFactory(frameFactory, null);

    }

    @SuppressWarnings("unchecked")

    public IFFrame createFrame(String frameName) {

        Iterator<Extension> iterator =

            ToolsLocator.getExtensionPointManager().get(KEY_LAYOUT_FFRAME)

                .iterator();

        while (iterator.hasNext()) {

            try {

                FrameFactory frameFactory =

                    (FrameFactory) iterator.next().create();

                if (frameFactory.getRegisterName().equals(frameName)) {

                    IFFrame frame = frameFactory.createFrame();

                    if (frame == null) {

                        return null;

                    }

                    frame.setFrameFactory(frameFactory);

                    return frame;

                }

            } catch (Exception e) {

                NotificationManager.addError(e);

            }

        }

        return null;

    }

    @SuppressWarnings("unchecked")

    public void registerFFrameDialog(String name, Class clazz) {

        if (!IFFrameDialog.class.isAssignableFrom(clazz)) {

            throw new IllegalArgumentException(clazz.getName()

                + " must implement the IFFrameDialog interface");

        }

        ExtensionPoint extensionPoint =

            extensionPoints.add(KEY_LAYOUT_FFRAMEDIALOG, "");

        extensionPoint.append(name, name, clazz);

    }

    public IWindow getPropertiesWindow(Document doc) {

        return new MapProperties((LayoutDocument) doc);

    }

    /**

     * Registers in the points of extension the Factory with alias.

     *

     */

    public static void register() {

        DefaultLayoutManager factory = new DefaultLayoutManager();

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        manager.registerFactory(factory);

        ProjectManager.getInstance().registerDocumentFactory(factory);

        ProjectManager.getInstance().registerDocumentAction(TYPENAME,new CopyDocumentAction());

        ProjectManager.getInstance().registerDocumentAction(TYPENAME,new CutDocumentAction());

        ProjectManager.getInstance().registerDocumentAction(TYPENAME,new PasteDocumentAction());

        if (factory.persistenceDefinition == null) {

            factory.persistenceDefinition =

                manager.addDefinition(LayoutDocument.class,

                    PERSISTENCE_LAYOUT_DOCUMENT_DEFINITION_NAME,

                    "Layout document Persistence definition", null, null);

            factory.persistenceDefinition.extend(manager

                .getDefinition(AbstractDocument.PERSISTENCE_DEFINITION_NAME));

            factory.persistenceDefinition

                .addDynFieldObject(DefaultLayoutDocument.LAYOUT_CONTEXT_OBJECT)

                .setClassOfValue(LayoutContext.class).setMandatory(false);

            DefaultLayoutPanel.registerPersistent();

            DefaultLayoutContext.registerPersistent();

        }

    }

    public int getPriority() {

        return 2;

    }

    /**

     * Sets whether the grid should be shown.

     *

     * @param showGrid

     */

    public void setDefaultShowGrid(boolean showGrid) {

        defaultShowGrid = new Boolean(showGrid);

    }

    /**

     * Sets whether the snapping to grid should be enabled or not

     *

     * @param gridEnable

     */

    public void setDefaultAdjustToGrid(boolean gridEnabled) {

        defaultAdjustToGrid = new Boolean(gridEnabled);

    }

    /**

     * Sets whether the ruler should be shown or not

     *

     * @param showRuler

     */

    public void setDefaultShowRulers(boolean showRules) {

        defaultShowRulers = new Boolean(showRules);

    }

    /**

     * Returns if the grid should be shown.

     *

     * @return True if the grid should be shown.

     */

    public boolean getDefaultShowGrid() {

        if (defaultShowGrid == null) {

                XMLEntity xml = PluginsLocator.getManager().getPlugin(this).getPersistentXML();

            if (xml.contains(PreferenceKeys.DEFAULT_SHOW_LAYOUT_GRID_KEY_NAME)) {

                defaultShowGrid =

                    new Boolean(xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_GRID_KEY_NAME));

            } else {

                defaultShowGrid = new Boolean(PreferenceKeys.FACTORY_DEFAULT_LAYOUT_GRID_SHOW);

            }

        }

        return defaultShowGrid.booleanValue();

    }

    /**

     * Returns if the adjust to grid should be active.

     *

     * @return True if the adjust to grid should be active.

     */

    public boolean getDefaultAdjustToGrid() {

        if (defaultAdjustToGrid == null) {

                XMLEntity xml = PluginsLocator.getManager().getPlugin(this).getPersistentXML();

            if (xml.contains(PreferenceKeys.DEFAULT_ENABLE_LAYOUT_GRID_KEY_NAME)) {

                defaultAdjustToGrid =

                    new Boolean(

                        xml.getBooleanProperty(PreferenceKeys.DEFAULT_ENABLE_LAYOUT_GRID_KEY_NAME));

            } else {

                defaultAdjustToGrid = new Boolean(PreferenceKeys.FACTORY_DEFAULT_LAYOUT_GRID_ENABLE);

            }

        }

        return defaultAdjustToGrid.booleanValue();

    }

    /**

     * Returns if the ruler should be shown.

     *

     * @return True if the ruler should be shown.

     */

    public boolean getDefaultShowRulers() {

        if (defaultShowRulers == null) {

                XMLEntity xml = PluginsLocator.getManager().getPlugin(this).getPersistentXML();

            if (xml.contains(PreferenceKeys.DEFAULT_SHOW_LAYOUT_RULERS_KEY_NAME)) {

                defaultShowRulers =

                    new Boolean(

                        xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_RULERS_KEY_NAME));

            } else {

                defaultShowRulers = new Boolean(PreferenceKeys.FACTORY_DEFAULT_LAYOUT_ENABLE_RULERS);

            }

        }

        return defaultShowRulers.booleanValue();

    }

    public boolean getDefaultShowInitialPageConfigDialog() {

            XMLEntity xml = PluginsLocator.getManager().getPlugin(this).getPersistentXML();

            boolean value;

        if (xml.contains(PreferenceKeys.DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_KEY_NAME)) {

            value = xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_KEY_NAME);

        } else {

                value = PreferenceKeys.FACTORY_DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_FOR_LAYOUT;

        }

        return value;

    }

    public DynStruct getDefinition(String className) {

        if (this.persistenceDefinition.getName().equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if (this.persistenceDefinition.getFullName()

            .equalsIgnoreCase(className)) {

            return this.persistenceDefinition;

        }

        if (this.getDocumentClass().getName().equals(className)) {

            return this.persistenceDefinition;

        }

        return null;

    }

    @SuppressWarnings("unchecked")

    protected Class getDocumentClass() {

        return DefaultLayoutDocument.class;

    }

    public boolean manages(Object object) {

        return object instanceof LayoutDocument;

    }

    public void registerLayoutMenuAction(String name,

        Class<? extends IContextMenuAction> clazz) {

        ExtensionPoint extensionPoint =

            ToolsLocator.getExtensionPointManager().add(LAYOUT_CONTEXT_MENUS);

        extensionPoint.append(name, "", clazz);

    }

    public IContextMenuAction[] createLayoutMenuActions(LayoutPanel layoutPanel) {

        List<IContextMenuAction> actionArrayList =

            new ArrayList<IContextMenuAction>();

        @SuppressWarnings("unchecked")

        Iterator<ExtensionPoint.Extension> iter =

            ToolsLocator.getExtensionPointManager().get(LAYOUT_CONTEXT_MENUS).iterator();

        AbstractLayoutContextMenuAction action;

        while (iter.hasNext()) {

            action = null;

            try {

                action = (AbstractLayoutContextMenuAction) iter.next().create();

            } catch (InstantiationException e) {

                LOG.error("Error creating the context menu", e);

            } catch (IllegalAccessException e) {

                LOG.error("Error creating the context menu", e);

            }

            if (action != null) {

                action.setLayout(layoutPanel);

                if (action.isVisible(null, layoutPanel.getLayoutContext().getSelectedFFrames())) {

                    actionArrayList.add(action);

                }

            }

        }

        IContextMenuAction[] result =

            (IContextMenuAction[]) Array.newInstance(IContextMenuAction.class,

                actionArrayList.size());

        System.arraycopy(actionArrayList.toArray(), 0, result, 0,

            actionArrayList.size());

        Arrays.sort(result, new CompareAction());

        return result;

    }

    private class CompareAction implements Comparator<IContextMenuAction> {

        public int compare(IContextMenuAction o1, IContextMenuAction o2) {

            NumberFormat formater = NumberFormat.getInstance();

            formater.setMinimumIntegerDigits(3);

            String key1 =

                "" + formater.format(o1.getGroupOrder()) + o1.getGroup()

                    + formater.format(o1.getOrder());

            String key2 =

                "" + formater.format(o2.getGroupOrder()) + o2.getGroup()

                    + formater.format(o2.getOrder());

            return key1.compareTo(key2);

        }

    }

}