Application: gvSIG desktop » gvSIG Document Layout

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.app.document.layout2.app</artifactId>

    <packaging>pom</packaging>

    <version>2.0.74</version>

    <name>${project.artifactId}</name>

    <description>This plugin adds creation/management of layout (map) documents.</description>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.desktop</artifactId>

        <version>2.0.127</version>

    </parent>

	<url>https://devel.gvsig.org/redmine/projects/gvsig-app-document-layout</url>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-app-document-layout/tags/org.gvsig.app.document.layout2.app-2.0.74</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-app-document-layout/tags/org.gvsig.app.document.layout2.app-2.0.74</developerConnection>

        <url>https://devel.gvsig.org/redmine/projects/gvsig-app-document-layout/repository/show/tags/org.gvsig.app.document.layout2.app-2.0.74</url>

    </scm>

    <repositories>

      <repository>

        <id>gvsig-public-http-repository</id>

        <name>gvSIG maven public HTTP repository</name>

        <url>http://devel.gvsig.org/m2repo/j2se</url>

        <releases>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </releases>

        <snapshots>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </snapshots>

      </repository>

    </repositories>

	<build>

		<plugins>

			<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-release-plugin</artifactId>

				<configuration>

					<tagBase>https://devel.gvsig.org/svn/gvsig-app-document-layout/tags</tagBase>

				</configuration>

			</plugin>

		</plugins>

	</build>

    <dependencyManagement>

         <dependencies>

            <!--

            Versions of child projects

            -->

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.app.document.layout2.app.mainplugin</artifactId>

                <version>2.0.74</version>

            </dependency>

        </dependencies>

    </dependencyManagement>

	<modules>

		<module>org.gvsig.app.document.layout2.app.mainplugin</module>

	</modules>

</project>

#Mon Feb 15 08:45:33 CET 2016

buildNumber=93

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	org.gvsig.tools packages.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.tools">

		<priority value="DEBUG" />

	</category>

	<category name="org.gvsig.app.document.layout">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

/* 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.gui.preferencespage;

import java.awt.Dimension;

import java.awt.GridLayout;

import javax.swing.ButtonGroup;

import javax.swing.ImageIcon;

import javax.swing.JCheckBox;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JRadioButton;

import javax.swing.JTextField;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.preferences.AbstractPreferencePage;

import org.gvsig.andami.preferences.StoreException;

public class PrintPropertiesPage extends AbstractPreferencePage {

    private static final long serialVersionUID = 5806304468312341691L;

    private static final boolean FACTORY_DEFAULT_LANDSCAPED_PAGE = true;

    protected static String id = PrintPropertiesPage.class.getName();

    private ImageIcon icon;

    private JRadioButton rdBtnPortraitPage;

    private JRadioButton rdBtnLandscapePage;

    private JCheckBox chkCustomMargins;

    private JTextField txtTopMargin;

    private JTextField txtLeftMargin;

    private JTextField txtBottomMargin;

    private JTextField txtRightMargin;

    public PrintPropertiesPage() {

        super();

        setParentID(LayoutPage.class.getName());

        icon = PluginServices.getIconTheme().get("prepare-page-icon");

        rdBtnPortraitPage =

            new JRadioButton(PluginServices.getText(this,

                "options.layout.paper_properties.portrait"));

        ImageIcon portrait =

            PluginServices.getIconTheme().get("portrait-page-setup");

        rdBtnLandscapePage =

            new JRadioButton(PluginServices.getText(this,

                "options.layout.paper_properties.landscaped"));

        ImageIcon landscape =

            PluginServices.getIconTheme().get("landscape-page-setup");

        ButtonGroup group = new ButtonGroup();

        group.add(rdBtnLandscapePage);

        group.add(rdBtnPortraitPage);

        JPanel aux = new JPanel(new GridLayout(2, 2, 10, 0));

        aux.setPreferredSize(new Dimension(200, 150));

        aux.setSize(200, 150);

        aux.add(new JLabel(landscape));

        aux.add(new JLabel(portrait));

        aux.add(rdBtnLandscapePage);

        aux.add(rdBtnPortraitPage);

        addComponent(new JLabel(PluginServices.getText(this,

            "options.layout.paper_properties.paper_direction")));

        addComponent("", aux);

        addComponent(chkCustomMargins =

            new JCheckBox(PluginServices.getText(this, "personalizar_margenes")));

        JPanel aux2 = new JPanel(new GridLayout(2, 4, 10, 3));

        aux2.add(new JLabel(PluginServices.getText(this, "Superior")));

        aux2.add(txtTopMargin = new JTextField(10));

        aux2.add(new JLabel(PluginServices.getText(this, "Izquierdo")));

        aux2.add(txtLeftMargin = new JTextField(10));

        aux2.add(new JLabel(PluginServices.getText(this, "Inferior")));

        aux2.add(txtBottomMargin = new JTextField(10));

        aux2.add(new JLabel(PluginServices.getText(this, "Derecho")));

        aux2.add(txtRightMargin = new JTextField(10));

        addComponent("", aux2);

    }

    public void storeValues() throws StoreException {

        // TODO Auto-generated method stub

    }

    public void setChangesApplied() {

        // TODO Auto-generated method stub

    }

    public String getID() {

        return id;

    }

    public String getTitle() {

        return PluginServices.getText(this,

            "options.layout.paper_properties.title");

    }

    public JPanel getPanel() {

        return this;

    }

    public void initializeValues() {

        // TODO Auto-generated method stub

    }

    public void initializeDefaults() {

        rdBtnLandscapePage.setSelected(FACTORY_DEFAULT_LANDSCAPED_PAGE);

        rdBtnPortraitPage.setSelected(!FACTORY_DEFAULT_LANDSCAPED_PAGE);

    }

    public ImageIcon getIcon() {

        return icon;

    }

    public boolean isValueChanged() {

        // TODO Auto-generated method stub

        return false;

    }

}

/* 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.gui.preferencespage;

import java.awt.GridBagConstraints;

import java.awt.Insets;

import javax.swing.BorderFactory;

import javax.swing.ImageIcon;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTextField;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.preferences.AbstractPreferencePage;

import org.gvsig.andami.preferences.StoreException;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.layout.Attributes;

import org.gvsig.app.project.documents.layout.DefaultLayoutManager;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.gui.beans.swing.GridBagLayoutPanel;

import org.gvsig.i18n.Messages;

import org.gvsig.utils.XMLEntity;

/**

 * Layout preference page where the user can establish default values for

 * <ol>

 * <li><b>grid horizontal gap</b></li>

 * <li><b>grid vertical gap</b></li>

 * <li><b>show or hide grid</b></li>

 * <li><b>adjust elements to grid</b></li>

 * <li><b>show or hide rules</b></li>

 * </ol>

 * 

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 * 

 */

public class LayoutPage extends AbstractPreferencePage {

    private static final long serialVersionUID = -8225970409668105935L;

    static String id = LayoutPage.class.getName();;

    private ImageIcon icon;

    private JCheckBox chkGridEnabled;

    private JCheckBox chkShowRules;

    private JCheckBox chkShowGrid;

    private JTextField txtVGap;

    private JTextField txtHGap;

    private JCheckBox chkShowInitialPageConfig;

	private JCheckBox chkShowLayoutTOC;

	private JComboBox cbHGapUnit;

	private JComboBox cbVGapUnit;

    private static DefaultLayoutManager layoutManager = null;

    /**

     * Builds preference page where the user can establish default values for

     * <ol>

     * <li><b>grid horizontal gap</b></li>

     * <li><b>grid vertical gap</b></li>

     * <li><b>show or hide grid</b></li>

     * <li><b>adjust elements to grid</b></li>

     * <li><b>show or hide rules</b></li>

     * </ol>

     */

    public LayoutPage() {

        super();

        layoutManager =

            (DefaultLayoutManager) ProjectManager.getInstance()

                .getDocumentManager(DefaultLayoutManager.TYPENAME);

        icon = IconThemeHelper.getImageIcon("document-map-icon");

        GridBagLayoutPanel gridRulerPanel = new GridBagLayoutPanel();

        Insets topInsets = new Insets(10, 10, 0, 10);

        Insets insets = new Insets(8, 10, 0, 10);

        Insets lastInsets = new Insets(8, 10, 12, 10);

        gridRulerPanel.setBorder(BorderFactory.createTitledBorder(Messages.getText("Grid_and_ruler")));

        // horizontal gap text field and units combo

        cbHGapUnit = new JComboBox();

        String[] names = MapContext.getDistanceNames();

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

        	cbHGapUnit.addItem(PluginServices.getText(this, names[i]));

        }

        gridRulerPanel.addComponent(new JLabel(PluginServices.getText(this, "espaciado_horizontal")),

            txtHGap = new JTextField(5), cbHGapUnit, GridBagConstraints.NONE, insets);

        // vertical gap text field and units combo

        cbVGapUnit = new JComboBox();

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

        	cbVGapUnit.addItem(PluginServices.getText(this, names[i]));

        }

        gridRulerPanel.addComponent(new JLabel(PluginServices.getText(this, "espaciado_vertical")),

        		txtVGap = new JTextField(5), cbVGapUnit, GridBagConstraints.NONE, insets);

        // show/hide show check

        gridRulerPanel.addComponent(chkShowGrid =

            new JCheckBox(PluginServices.getText(this, "visualizar_cuadricula")), insets);

        // enable/disable grid

        gridRulerPanel.addComponent(chkGridEnabled =

            new JCheckBox(PluginServices.getText(this, "malla_activada")), insets);

        // show/hide rules

        gridRulerPanel.addComponent(chkShowRules =

            new JCheckBox(PluginServices.getText(this, "activar_regla")), lastInsets);

        addComponent(gridRulerPanel, topInsets);

        GridBagLayoutPanel behaviourPanel = new GridBagLayoutPanel();

        behaviourPanel.setBorder(BorderFactory.createTitledBorder(Messages.getText("User_interface")));

        behaviourPanel.addComponent(

        		chkShowInitialPageConfig = new JCheckBox(Messages.getText("Show_page_config_dialog_when_layout_document_is_created")),

        		insets);

        behaviourPanel.addComponent(

        		chkShowLayoutTOC = new JCheckBox(Messages.getText("Show_table_of_contents_TOC_for_Layout_views")),

        		insets);

        addComponent(behaviourPanel, lastInsets);

    }

    public void storeValues() throws StoreException {

        double hGap, vGap;

        boolean gridEnabled, showRules, showGrid, showInitPageConfig,

        	showLayoutToc;

        String hGapUnits, vGapUnits;

        try {

            hGap = Double.parseDouble(txtHGap.getText());

            hGapUnits = MapContext.getDistanceAbbr()[cbHGapUnit.getSelectedIndex()];

            vGap = Double.parseDouble(txtVGap.getText());

            vGapUnits = MapContext.getDistanceAbbr()[cbVGapUnit.getSelectedIndex()];

            gridEnabled = chkGridEnabled.isSelected();

            showGrid = chkShowGrid.isSelected();

            showRules = chkShowRules.isSelected();

            showInitPageConfig = chkShowInitialPageConfig.isSelected();

            showLayoutToc = chkShowLayoutTOC.isSelected();

        } catch (Exception e) {

            throw new StoreException(PluginServices.getText(this,

                "invalid_value_for_gap"));

        }

        layoutManager.setDefaultShowGrid(showGrid);

        layoutManager.setDefaultAdjustToGrid(gridEnabled);

        layoutManager.setDefaultShowRulers(showRules);

        Attributes.setDefaultGridGap(hGap, vGap, hGapUnits, vGapUnits);

        PluginServices ps = PluginsLocator.getManager().getPlugin(this);

		XMLEntity xml = ps.getPersistentXML();

        xml.putProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_KEY_NAME, hGap);

        xml.putProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_VERTICAL_GAP_KEY_NAME, vGap);

        xml.putProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_UNITS_KEY_NAME, hGapUnits);

        xml.putProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_VERTICAL_GAP_UNITS_KEY_NAME, vGapUnits);

        xml.putProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_GRID_KEY_NAME, showGrid);

        xml.putProperty(PreferenceKeys.DEFAULT_ENABLE_LAYOUT_GRID_KEY_NAME, gridEnabled);

        xml.putProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_RULERS_KEY_NAME, showRules);

        xml.putProperty(PreferenceKeys.DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_KEY_NAME, showInitPageConfig);

        xml.putProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_TOC_KEY_NAME, showLayoutToc);

    }

    public String getID() {

        return id;

    }

    public String getTitle() {

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

    }

    public JPanel getPanel() {

        return this;

    }

    public void initializeValues() {

    	PluginServices ps = PluginsLocator.getManager().getPlugin(this);

		XMLEntity xml = ps.getPersistentXML();

        double hGap = PreferenceKeys.FACTORY_DEFAULT_HORIZONTAL_GAP;

        double vGap = PreferenceKeys.FACTORY_DEFAULT_VERTICAL_GAP;

        boolean showGrid = PreferenceKeys.FACTORY_DEFAULT_LAYOUT_GRID_SHOW;

        boolean gridEnabled = PreferenceKeys.FACTORY_DEFAULT_LAYOUT_GRID_ENABLE;

        boolean showRules = PreferenceKeys.FACTORY_DEFAULT_LAYOUT_ENABLE_RULERS;

        boolean showInitPageConfig = PreferenceKeys.FACTORY_DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_FOR_LAYOUT;

        boolean showLayoutToc = PreferenceKeys.FACTORY_DEFAULT_SHOW_LAYOUT_TOC;

        // horizontal gap

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

            hGap =

                xml.getDoubleProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_KEY_NAME);

        }

        txtHGap.setText(String.valueOf(hGap));

        // vertical gap

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

            vGap =

                xml.getDoubleProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_VERTICAL_GAP_KEY_NAME);

        }

        txtVGap.setText(String.valueOf(vGap));

        String hGapUnit = xml.contains(PreferenceKeys.DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_UNITS_KEY_NAME)?

        		xml.getStringProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_UNITS_KEY_NAME):

        			PreferenceKeys.FACTORY_DEFAULT_HORIZONTAL_GAP_UNIT;

        cbHGapUnit.setSelectedIndex(Attributes.getDistanceAbbrPosition(hGapUnit));

        String vGapUnit = xml.contains(PreferenceKeys.DEFAULT_LAYOUT_GRID_VERTICAL_GAP_UNITS_KEY_NAME)?

                		xml.getStringProperty(PreferenceKeys.DEFAULT_LAYOUT_GRID_VERTICAL_GAP_UNITS_KEY_NAME):

                			PreferenceKeys.FACTORY_DEFAULT_VERTICAL_GAP_UNIT;

        cbVGapUnit.setSelectedIndex(Attributes.getDistanceAbbrPosition(vGapUnit));

        // show/hide grid check

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

            showGrid =

                xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_GRID_KEY_NAME);

        }

        chkShowGrid.setSelected(showGrid);

        // enable/disable grid check

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

            gridEnabled =

                xml.getBooleanProperty(PreferenceKeys.DEFAULT_ENABLE_LAYOUT_GRID_KEY_NAME);

        }

        chkGridEnabled.setSelected(gridEnabled);

        // enable/disable rules

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

            showRules =

                xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_RULERS_KEY_NAME);

        }

        chkShowRules.setSelected(showRules);

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

        	showInitPageConfig = xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_KEY_NAME);

        }

        chkShowInitialPageConfig.setSelected(showInitPageConfig);

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

        	showLayoutToc = xml.getBooleanProperty(PreferenceKeys.DEFAULT_SHOW_LAYOUT_TOC_KEY_NAME);

        }

        chkShowLayoutTOC.setSelected(showLayoutToc);

        layoutManager.setDefaultShowGrid(showGrid);

        layoutManager.setDefaultAdjustToGrid(gridEnabled);

        layoutManager.setDefaultShowRulers(showRules);

        Attributes.setDefaultGridGap(hGap, vGap, hGapUnit, vGapUnit);

    }

    public void initializeDefaults() {

        txtHGap.setText(String.valueOf(PreferenceKeys.FACTORY_DEFAULT_HORIZONTAL_GAP));

        txtVGap.setText(String.valueOf(PreferenceKeys.FACTORY_DEFAULT_VERTICAL_GAP));

        cbHGapUnit.setSelectedIndex(Attributes.getDistanceAbbrPosition(PreferenceKeys.FACTORY_DEFAULT_HORIZONTAL_GAP_UNIT));

        cbVGapUnit.setSelectedIndex(Attributes.getDistanceAbbrPosition(PreferenceKeys.FACTORY_DEFAULT_VERTICAL_GAP_UNIT));

        chkShowGrid.setSelected(PreferenceKeys.FACTORY_DEFAULT_LAYOUT_GRID_SHOW);

        chkGridEnabled.setSelected(PreferenceKeys.FACTORY_DEFAULT_LAYOUT_GRID_ENABLE);

        chkShowRules.setSelected(PreferenceKeys.FACTORY_DEFAULT_LAYOUT_ENABLE_RULERS);

        chkShowInitialPageConfig.setSelected(PreferenceKeys.FACTORY_DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_FOR_LAYOUT);

    }

    public ImageIcon getIcon() {

        return icon;

    }

    public boolean isValueChanged() {

        return super.hasChanged();

    }

    public void setChangesApplied() {

        setChanged(false);

    }

}

package org.gvsig.app.gui.preferencespage;

/**

 * The purpose of this interface is to define the keys used for the

 * persistence of this plugin in order to make these keys available

 * on library level, instead of defining them within the

 * preference page (which has UI dependences).

 * 

 * @author Cesar Martinez Izquierdo <cesar.izq@gmail.com>

 *

 */

public interface PreferenceKeys {

    String DEFAULT_SHOW_LAYOUT_GRID_KEY_NAME = "DefaultShowLayoutGrid";

    String DEFAULT_ENABLE_LAYOUT_GRID_KEY_NAME = "DefaultEnableLayoutGrid";

    String DEFAULT_SHOW_LAYOUT_RULERS_KEY_NAME = "DefaultShowLayoutRules";

    String DEFAULT_LAYOUT_GRID_VERTICAL_GAP_KEY_NAME = "DefaultGridVerticalGap";

    String DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_KEY_NAME = "DefaultGridHorizontalGap";

    String DEFAULT_LAYOUT_GRID_VERTICAL_GAP_UNITS_KEY_NAME = "DefaultGridVerticalGapUnits";

    String DEFAULT_LAYOUT_GRID_HORIZONTAL_GAP_UNITS_KEY_NAME = "DefaultGridHorizontalGapUnits";

    String DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_KEY_NAME = "DefaulShowInitialPageConfigLayout";

    String DEFAULT_SHOW_LAYOUT_TOC_KEY_NAME = "DefaultShowLayoutToc";

    boolean FACTORY_DEFAULT_LAYOUT_ENABLE_RULERS = true;

    boolean FACTORY_DEFAULT_LAYOUT_GRID_SHOW = true;

    double FACTORY_DEFAULT_VERTICAL_GAP = 1.0d;

    double FACTORY_DEFAULT_HORIZONTAL_GAP = 1.0d;

    String FACTORY_DEFAULT_VERTICAL_GAP_UNIT = "cm";

    String FACTORY_DEFAULT_HORIZONTAL_GAP_UNIT = "cm";

    boolean FACTORY_DEFAULT_LAYOUT_GRID_ENABLE = false;

    boolean FACTORY_DEFAULT_SHOW_INITIAL_CONFIG_DIALOG_FOR_LAYOUT = true;

    boolean FACTORY_DEFAULT_SHOW_LAYOUT_TOC = true;

}

/* 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.Color;

import java.awt.Cursor;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.Toolkit;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.geom.Rectangle2D.Double;

import java.awt.image.BufferedImage;

import java.awt.image.MemoryImageSource;

import java.util.HashMap;

import javax.swing.JComponent;

import org.gvsig.andami.PluginsLocator;

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

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

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

import org.gvsig.app.project.documents.layout.geometryadapters.GeometryAdapter;

import org.gvsig.app.project.documents.layout.geometryadapters.PolyLineAdapter;

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

import org.gvsig.app.project.documents.layout.tools.LayoutAddBoxListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddCircleListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddLegendListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddLineListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddNorthListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddOverViewListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPictureListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPointListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPolygonListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddPolylineListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddRectangleListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddScaleListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddTextListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutAddViewListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutEditGraphicsListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutPanListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutSelectListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutViewPanListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutViewZoomInListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutViewZoomOutListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutZoomInListenerImpl;

import org.gvsig.app.project.documents.layout.tools.LayoutZoomOutListenerImpl;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutEditBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutMoveBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutPointBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutRectangleBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutSelectBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutViewMoveBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutViewZoomBehavior;

import org.gvsig.app.project.documents.layout.tools.behavior.LayoutZoomBehavior;

import org.gvsig.app.project.documents.layout.tools.listener.ILayoutGraphicListener;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.tools.observer.Observable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Control of Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class DefaultLayoutControl extends JComponent implements LayoutControl {

    private static final int DESACTUALIZADO = 4;

    private static final int ACTUALIZADO = 5;

    private static final long serialVersionUID = -8290006366669291510L;

    public static final String PERSISTENCE_DEFINITION_NAME = "LayoutControl";

    private int status = DESACTUALIZADO;

    private Rectangle2D rectVisible;

    private BufferedImage img = null;

    private BufferedImage imgRuler = null;

    private LayoutContext layoutContext;

    private Point origin = new Point(50, 50);

    private Point rectOrigin = new Point(origin);

    /**

     * Size and position of the layout sheet within visible area of

     * the layout component, measured in screen coordinates (pixels).

     */

    private Rectangle2D.Double rect = new Rectangle2D.Double(rectOrigin.x,

        rectOrigin.y, 400, 300);

    /**

     * Visible area of the layout document, measured on paper coordinates.

     */

    private Rectangle2D.Double viewPort = new Rectangle2D.Double();

    private FLayoutDraw layoutDraw = null;

    private FLayoutFunctions layoutFunctions = null;

    private LayoutBehavior currentLayoutTool = null;

    private Image imageCursor = null;

    private HashMap namesLayoutTools = new HashMap();

    private Point m_FirstPoint = new Point(0, 0);

    private Point m_PointAnt = new Point(0, 0);

    private Point m_LastPoint = new Point(0, 0);

    private LayoutEvents layoutEvents;

    private Point position;

    private GeometryAdapter geometryAdapter = new PolyLineAdapter();

    private String currentTool;

    private boolean m_bCancelDrawing = false;

    private Rectangle reSel = null;

    private boolean isReSel = true;

    private FLayoutZooms layoutZooms;

	private LayoutPanel layoutPanel;

    private static Cursor transparentCursor = Toolkit.getDefaultToolkit()

        .createCustomCursor(

            Toolkit.getDefaultToolkit().createImage(

                new MemoryImageSource(16, 16, new int[16 * 16], 0, 16)),

            new Point(0, 0), "invisiblecursor");

    /**

     * Create a new object of LayoutControl.

     * 

     * @param layout

     */

    public DefaultLayoutControl() {  

    }

    public void initialize(LayoutPanel layoutPanel){

    	setFocusable(true);

    	this.layoutPanel = layoutPanel;

        layoutDraw = new FLayoutDraw(layoutPanel);

        layoutEvents = new LayoutEvents(layoutPanel);

        layoutZooms = new FLayoutZooms(layoutPanel);

        layoutFunctions = new FLayoutFunctions(layoutPanel);

        addComponentListener(layoutEvents);

        addMouseMotionListener(layoutEvents);

        addMouseListener(layoutEvents);

        LayoutPanListenerImpl lpl = new LayoutPanListenerImpl(layoutPanel);

        addLayoutTool("layoutpan", new LayoutMoveBehavior(lpl));

        LayoutZoomInListenerImpl lzil = new LayoutZoomInListenerImpl(layoutPanel);

        addLayoutTool("layoutzoomin", new LayoutZoomBehavior(lzil));

        LayoutZoomOutListenerImpl lzol = new LayoutZoomOutListenerImpl(layoutPanel);

        addLayoutTool("layoutzoomout", new LayoutZoomBehavior(lzol));

        LayoutAddViewListenerImpl lavl = new LayoutAddViewListenerImpl(layoutPanel);

        addLayoutTool("layoutaddview", new LayoutRectangleBehavior(lavl));

        LayoutAddOverViewListenerImpl laovl =

            new LayoutAddOverViewListenerImpl(layoutPanel);

        addLayoutTool("layoutaddoverview", new LayoutRectangleBehavior(laovl));

        LayoutAddPictureListenerImpl lapl =

            new LayoutAddPictureListenerImpl(layoutPanel);

        addLayoutTool("layoutaddpicture", new LayoutRectangleBehavior(lapl));

        LayoutAddNorthListenerImpl lanorthl =

            new LayoutAddNorthListenerImpl(layoutPanel);

        addLayoutTool("layoutaddnorth", new LayoutRectangleBehavior(lanorthl));

        LayoutAddScaleListenerImpl lasl =

            new LayoutAddScaleListenerImpl(layoutPanel);

        addLayoutTool("layoutaddscale", new LayoutRectangleBehavior(lasl));

        LayoutAddLegendListenerImpl lall =

            new LayoutAddLegendListenerImpl(layoutPanel);

        addLayoutTool("layoutaddlegend", new LayoutRectangleBehavior(lall));

        LayoutAddTextListenerImpl latl = new LayoutAddTextListenerImpl(layoutPanel);

        addLayoutTool("layoutaddtext", new LayoutRectangleBehavior(latl));

        LayoutAddBoxListenerImpl labl = new LayoutAddBoxListenerImpl(layoutPanel);

        addLayoutTool("layoutaddbox", new LayoutRectangleBehavior(labl));

        LayoutAddPointListenerImpl lapointl =

            new LayoutAddPointListenerImpl(layoutPanel);

        addLayoutTool("layoutaddpoint", new LayoutPointBehavior(lapointl));

        LayoutAddLineListenerImpl lalinel =

            new LayoutAddLineListenerImpl(layoutPanel);

        addLayoutTool("layoutaddline", new LayoutPointBehavior(lalinel));

        LayoutAddPolygonListenerImpl lapolygonl =

            new LayoutAddPolygonListenerImpl(layoutPanel);

        addLayoutTool("layoutaddpolygon", new LayoutPointBehavior(lapolygonl));

        LayoutAddPolylineListenerImpl lapolylinel =

            new LayoutAddPolylineListenerImpl(layoutPanel);

        addLayoutTool("layoutaddpolyline", new LayoutPointBehavior(lapolylinel));

        LayoutAddCircleListenerImpl lacirclel =

            new LayoutAddCircleListenerImpl(layoutPanel);

        addLayoutTool("layoutaddcircle", new LayoutPointBehavior(lacirclel));

        LayoutAddRectangleListenerImpl larectanglel =

            new LayoutAddRectangleListenerImpl(layoutPanel);

        addLayoutTool("layoutaddrectangle", new LayoutPointBehavior(

            larectanglel));

        LayoutViewPanListenerImpl lvpl = new LayoutViewPanListenerImpl(layoutPanel);

        addLayoutTool("layoutviewpan", new LayoutViewMoveBehavior(lvpl));

        LayoutViewZoomInListenerImpl lvzil =

            new LayoutViewZoomInListenerImpl(layoutPanel);

        addLayoutTool("layoutviewzoomin", new LayoutViewZoomBehavior(lvzil));

        LayoutViewZoomOutListenerImpl lvzol =

            new LayoutViewZoomOutListenerImpl(layoutPanel);

        addLayoutTool("layoutviewzoomout", new LayoutViewZoomBehavior(lvzol));

        LayoutSelectListenerImpl lselectl =

            new LayoutSelectListenerImpl(layoutPanel);

        addLayoutTool("layoutselect", new LayoutSelectBehavior(lselectl));

        LayoutEditGraphicsListenerImpl leditl =

            new LayoutEditGraphicsListenerImpl(layoutPanel);

        addLayoutTool("layoutedit", new LayoutEditBehavior(leditl));

    }

    public String getCurrentTool() {

        return currentTool;

    }

    public void addLayoutTool(String name, LayoutBehavior tool) {

        namesLayoutTools.put(name, tool);

        tool.setLayoutControl(this);

    }

    public void setLayoutContext(LayoutContext lc) {

        layoutContext = lc;

        layoutContext.addObserver(this);

        fullRect();

    }

    /**

     * paintComponent of Layout.

     * 

     * @param g

     *            Graphics of Layout.

     */

    protected void paintComponent(Graphics g) {

        clipVisibleRect((Graphics2D) g);

        Rectangle rClip = g.getClipBounds();

        if (rClip == null) {

            System.err.println("clip = null");

        }

        switch (status) {

        case DESACTUALIZADO:

            if (getWidth() == 0) {

                return;

            }

            img =

                new BufferedImage(getWidth(), getHeight(),

                    BufferedImage.TYPE_INT_ARGB);

            imgRuler =

                new BufferedImage(getWidth(), getHeight(),

                    BufferedImage.TYPE_INT_ARGB);

            Graphics gimag = img.getGraphics();

            Graphics gimgRuler = imgRuler.getGraphics();

            clipVisibleRect((Graphics2D) gimag);

            try {

                layoutDraw.drawLayout((Graphics2D) gimag, img);

            } catch (ReadException e) {

                e.printStackTrace();

            }

            g.setClip(rClip);

            layoutDraw.drawRectangle((Graphics2D) g);

            g.drawImage(img, 0, 0, this);

            g.setClip(rClip);

            layoutDraw.drawGrid((Graphics2D) gimgRuler);

            layoutDraw.drawRuler((Graphics2D) gimgRuler, Color.black);

            setStatus(ACTUALIZADO);

            repaint();

            break;

        case ACTUALIZADO:

            layoutDraw.drawRectangle((Graphics2D) g);

            if (currentLayoutTool != null) {

                currentLayoutTool.paintComponent(g);

            } else {

                g.drawImage(img, 0, 0, this);

                layoutDraw.drawHandlers((Graphics2D) g, Color.black);

            }

            g.setClip(rClip);

            drawCursor(g);

        }

    }

    private void setStatus(int s) {

        status = s;

    }

    /**

     * Clip on visible rectangle.

     * 

     * @param g2d

     *            Graphics.

     */

    private void clipVisibleRect(Graphics2D g2d) {

        rectVisible = this.getVisibleRect();

        g2d.clipRect((int) rectVisible.getMinX(), (int) rectVisible.getMinY(),

            (int) rectVisible.getWidth(), (int) rectVisible.getHeight());

    }

    public BufferedImage getImgRuler() {

        return imgRuler;

    }

    public void fullRect() {

        Rectangle2D r = new Rectangle2D.Double(origin.x, origin.y, getWidth(),

            getHeight());

        if (layoutContext.getAttributes().isLandscape()) {

            r =

                layoutContext.getAttributes().getRectangleLandscape(r,

                    getWidth(), getHeight());

        } else {

            r =

                layoutContext.getAttributes().getRectanglePortrait(r,

                    getWidth(), getHeight());

        }

        setRect(r);

        refresh();

    }

    public Rectangle2D.Double getRect() {

    	return (Rectangle2D.Double) rect.clone();

    }

    public void setRect(Rectangle2D r) {

        rect.setRect(r);

        Rectangle2D bounds = getBounds();

        if (rect.getWidth()>0 && bounds.getWidth()>0) { // only when the component has been laid out and rect properly initialized

        	// ensure the AT is properly initialized

        	layoutDraw.initializeAffineTransform();

        	AffineTransform at = layoutContext.getAT();

        	if (at!=null) {

        		Rectangle2D.Double newVp = new Rectangle2D.Double(0d, 0d, bounds.getWidth(), bounds.getHeight());

        		viewPort.setRect(FLayoutUtilities.toSheetRect(newVp, at));

        	}

        }

    }

    public BufferedImage getImage() {

        return img;

    }

    /**

     * Draw the cursor on the Graphics.

     * 

     * @param g

     *            Graphics.

     */

    private void drawCursor(Graphics g) {

        if ((imageCursor != null) && (position != null)) {

            Point pAdjusted = position;

            g.drawImage(imageCursor, (int) pAdjusted.getX() - 16,

                (int) pAdjusted.getY() - 16, this);

        }

    }

    public void setMapCursor(Image image) {

        imageCursor = image;

    }

    public void setTool(String toolName) {

        LayoutBehavior layoutTool =

            (LayoutBehavior) namesLayoutTools.get(toolName);

        currentLayoutTool = layoutTool;

        currentLayoutTool.setLayoutControl(this);

        currentTool = toolName;

        this.setMapCursor(layoutTool.getImageCursor());

        if (getCurrentLayoutTool().getListener() instanceof ILayoutGraphicListener) {

            geometryAdapter =

                ((ILayoutGraphicListener) getCurrentLayoutTool().getListener())

                    .createGeometryAdapter();

        }

        if (getCurrentTool().equals("layoutedit")) {

            startEdit();

        } else {

            stopEdit();

        }

    }

	public void setDefaultTool() {

        PluginsLocator.getMainFrame().setSelectedTool("selection-select-by-rectangle-layout");

        setTool("layoutselect");

	}

    public void startEdit() {

        IFFrame[] fframes = layoutContext.getFFrames();

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

            IFFrame frame = fframes[i];

            if (frame instanceof IFFrameEditableVertex) {

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

                    ((IFFrameEditableVertex) frame).startEditing();

                } else {

                    ((IFFrameEditableVertex) frame).stopEditing();

                }

            }

        }

        refresh();

    }

    public void stopEdit() {

        boolean refresh = false;

        IFFrame[] fframes = layoutContext.getFFrames();

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

            IFFrame frame = fframes[i];

            if (frame instanceof IFFrameEditableVertex) {

                if (((IFFrameEditableVertex) frame).isEditing()) {

                    ((IFFrameEditableVertex) fframes[i]).stopEditing();

                    refresh = true;

                }

            }

        }

        if (refresh) {

            refresh();

        }

    }

    public Point getRectOrigin() {

        return rectOrigin;

    }

    public FLayoutDraw getLayoutDraw() {

        return layoutDraw;

    }

    public LayoutBehavior getCurrentLayoutTool() {

        return currentLayoutTool;

    }

    public Point getFirstPoint() {

        return m_FirstPoint;

    }

    public Point getPointAnt() {

        return m_PointAnt;

    }

    public Point getLastPoint() {

        return m_LastPoint;

    }

    public void setFirstPoint() {

        m_FirstPoint = position;

    }

    public void setPointAnt() {

        m_PointAnt = position;

    }

    public void setLastPoint() {

        m_LastPoint = position;

    }

    public void setPosition(Point point2) {

        if (layoutContext.isAdjustingToGrid()

            && getCurrentLayoutTool().isAdjustable()) {

            position =

                FLayoutUtilities.getPointGrid(point2, layoutContext

                    .getAttributes().getHGridGapCm(), layoutContext

                    .getAttributes().getVGridGapCm(), layoutContext.getAT());

        } else {

            position = point2;

        }

    }

    public Point getPosition() {

        return position;

    }

    public AffineTransform getAT() {

        return layoutContext.getAT();

    }

    public GeometryAdapter getGeometryAdapter() {

        return geometryAdapter;

    }

    public void delLastPoint() {

        getGeometryAdapter().delLastPoint();

    }

    public int addGeometryAdapterPoint() {

        return getGeometryAdapter().addPoint(

            FLayoutUtilities.toSheetPoint(getPosition(), getAT()));

    }

    public void setGeometryAdapterPoinPosition() {

        getGeometryAdapter().pointPosition(

            FLayoutUtilities.toSheetPoint(getPosition(), getAT()));

    }

    public void clearMouseImage() {

        setCursor(transparentCursor);

    }

    public void refresh() {

    	AffineTransform at = calculateTransformFromViewport();

    	if (at!=null) {

        	// update rect according to the viewport rectangle

    		Size s = getLayoutContext().getAttributes().getPaperSize();

    		Rectangle2D paperRect = new Rectangle2D.Double(0, 0, s.getWidth(), s.getHeight());

    		Rectangle2D newRect = FLayoutUtilities.fromSheetRect(paperRect, at);

    		setRect(newRect);

    	}

    	// repaint

        setStatus(DESACTUALIZADO);

        invalidate();

        repaint();

    }

    /**

     * Calculates the affine transform using the viewport and the control size,

     * instead of calculating it from {@link #rect}. as usual. This is required when

     * the component size changes, as {@link #rect}. has to be recalculated using

     * the viewport, and thus we can't calculate the affine transform using

     * {@link #rect}.

     * 

     * @return An matrix to transform from paper coordinates to screen coordinates

     */

    protected AffineTransform calculateTransformFromViewport() {

    	Rectangle2D bounds = getBounds();

    	if (bounds.getWidth()>0 && viewPort.getHeight()>0) {

    		AffineTransform at = new AffineTransform();

    		// paper (paper units) to screen (pixels) scale

        	double scale, scale1, scale2;

        	scale1 = bounds.getHeight() / viewPort.getHeight() * 1;

        	scale2 = bounds.getWidth() / viewPort.getWidth() * 1;

        	scale = (scale1+scale2)/2d; // average scale

    		AffineTransform scaleAt = new AffineTransform();

    		AffineTransform translationAt = new AffineTransform();

    		translationAt.setToTranslation(-viewPort.getMinX(), -viewPort.getMinY());

    		scaleAt.setToScale(scale, scale);

    		at.concatenate(scaleAt);

    		at.concatenate(translationAt);

    		return at;

    	}

    	return null;

    }

    public synchronized boolean isDrawingCancelled() {

        return m_bCancelDrawing;

    }

    public synchronized void setCancelDrawing(boolean b) {

        m_bCancelDrawing = b;

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

            IFFrame fframe = layoutContext.getFFrame(i);

            if (fframe instanceof IFFrameUseFMap

                && (((IFFrameUseFMap) fframe).getMapContext() != null)) {

                // //TODO((FFrameView)

                // getFFrames().get(i)).getFMap().setCancelDrawing(b);

            }

        }

    }

    public Rectangle getReSel() {

        return reSel;

    }

    public boolean isReSel() {

        return isReSel;

    }

    public void setIsReSel(boolean b) {

        isReSel = b;

    }

    public void viewFull() throws ReadException {

        IFFrame[] fframes = layoutContext.getSelectedFFrames();

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

            if (fframes[i] instanceof IFFrameUseFMap) {

                IFFrameUseFMap fframe = (IFFrameUseFMap) fframes[i];

                if (fframe.getMapContext() != null) {

                    fframe.fullExtent();

                }

                fframe.refresh();

            }

        }

        refresh();

    }

    public FLayoutZooms getLayoutZooms() {

        return layoutZooms;

    }

    public FLayoutFunctions getLayoutFunctions() {

        return layoutFunctions;

    }

    public LayoutContext getLayoutContext() {

        return layoutContext;

    }

    public void setGeometryAdapter(GeometryAdapter adapter) {

        geometryAdapter = adapter;

    }

    public JComponent getComponent() {

        return this;

    }

    public void update(Observable observable, Object notification) {

       if ((notification != null) && (notification instanceof LayoutNotification)){

    	   LayoutNotification layoutNotification = (LayoutNotification)notification;

           if (LayoutNotification.LAYOUT_VALIDATED.equals(layoutNotification.getType())){

               status = ACTUALIZADO;

           }else if (LayoutNotification.LAYOUT_INVALIDATED.equals(layoutNotification.getType())){

               status = DESACTUALIZADO;

           }else if (LayoutNotification.LAYOUT_REFRESH.equals(layoutNotification.getType())){

               refresh();

           }

       }

    }

}

/* 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;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public interface LayoutNotification {

	/** Fired when the layout has to be invalidated */

    public static final String LAYOUT_INVALIDATED = "layout_invalidated";

    /** Fired when the layout doesn't have to be repainted */

    public static final String LAYOUT_VALIDATED = "layout_validated";

    /** Fired when the layout has to be invalidated and immediately repainted */

    public static final String LAYOUT_REFRESH = "layout_refresh";

    /**

     * Returns the type of this notification, represented by one of the constants defined in this interface.

     * @return a String containing this notification's type

     */

    public String getType();

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2015 gvSIG Association.

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.print.PageFormat;

import java.awt.print.Paper;

import java.text.NumberFormat;

import java.util.ArrayList;

import javax.print.attribute.DocAttributeSet;

import javax.print.attribute.HashDocAttributeSet;

import javax.print.attribute.HashPrintRequestAttributeSet;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.Copies;

import javax.print.attribute.standard.Fidelity;

import javax.print.attribute.standard.Media;

import javax.print.attribute.standard.MediaPrintableArea;

import javax.print.attribute.standard.MediaSizeName;

import javax.print.attribute.standard.OrientationRequested;

import javax.print.attribute.standard.PrintQuality;

import javax.print.attribute.standard.Sides;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;