| gvSIG desktop 1

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

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.andami.PluginServices;

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

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

import org.gvsig.compat.print.PrintAttributes;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.operations.Classifiable;

import org.gvsig.fmap.mapcontext.layers.operations.IHasImageLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IClassifiedLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ITextSymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolDrawingException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * FFrame para introducir una leyenda en el Layout.

 *

 * @author Vicente Caballero Navarro

 */

public class FFrameLegend extends AbstractFFrameViewDependence implements

    IFFrameViewDependence {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameLegend";

    private static final String NUMLAYERS_FIELD = "numLayers";

    private static final String MAX_FIELD = "max";

    private static final String QUALITY_FIELD = "quality";

    private static final String VIEWING_FIELD = "viewing";

    private static final String FONT_FIELD = "font";

    private static final String NAMELAYERS_FIELD = "nameLayers";

    private static final String AREVISIBLE_FIELD = "areVisible";

    private static final int PRESENTACION = 0;

    private static final int BORRADOR = 1;

    private int m_quality = 0;

    private int m_viewing = 0;

    private Font m_font = new Font("SansSerif", Font.PLAIN, 9);

    private int m_max;

    private int m_numLayers;

    private FLayers layers = null;

    private List<String> nameLayers = new ArrayList<String>();

    private List<Boolean> areVisible = new ArrayList<Boolean>();

    private PrintAttributes properties;

    private MapContextManager mapContextManager = MapContextLocator

        .getMapContextManager();

    public FFrameLegend() {

    }

    /**

     * Rellena la calidad que se quiere aplicar.

     *

     * @param q

     *            entero que representa la calidad a aplicar.

     */

    public void setQuality(int q) {

        m_quality = q;

    }

    /**

     * Devuelve un entero que representa la calidad que est? seleccionada.

     *

     * @return tipo de calidad selccionada.

     */

    public int getQuality() {

        return m_quality;

    }

    /**

     * Devuelve un entero que representa la forma en que se actualiza la vista.

     *

     * @return forma que se actualiza la vista.

     */

    public int getViewing() {

        return m_viewing;

    }

    /**

     * Rellena la forma de actualizar la vista.

     *

     * @param v

     *            entero que representa la forma de actualizar la vista.

     */

    public void setViewing(int v) {

        m_viewing = v;

    }

    /**

     * M?todo que dibuja sobre el graphics que se le pasa como par?metro, seg?n

     * la transformada afin que se debe de aplicar y el rect?ngulo que se debe

     * de dibujar.

     *

     * @param g

     *            Graphics

     * @param at

     *            Transformada afin.

     * @param rv

     *            rect?ngulo sobre el que hacer un clip.

     * @param imgBase

     *            Imagen para acelerar el dibujado.

     */

    public void draw(Graphics2D g, AffineTransform at, Rectangle2D rv,

        BufferedImage imgBase) {

        Rectangle2D.Double re = getBoundingBox(at);

        g.rotate(Math.toRadians(getRotation()), re.x + (re.width / 2), re.y

            + (re.height / 2));

        if ((fframeViewDependence != null)

            && (fframeViewDependence.getMapContext() != null)) {

            layers = fframeViewDependence.getMapContext().getLayers();

        }

        m_max = 0;

        m_numLayers = 0;

        if (intersects(rv, re)) {

            if (layers == null) { // Si no se ha seleccionado ninguna vista para

                                  // crear la leyenda.

                drawEmpty(g);

            } else

                if ((rv == null) || (getQuality() == PRESENTACION)) {

                    m_numLayers = getSizeNum(layers);

                    double h = re.getHeight() / m_numLayers;

                    int[] n = new int[1];

                    n[0] = 0;

                    drawLegendOrToFFrame(g, re, h, layers, n, null);

                } else

                    if (getQuality() == BORRADOR) { // Si se selecciona la

                                                    // calidad BORRADOR.

                        drawDraft(g);

                    }

        }

        g.rotate(Math.toRadians(-getRotation()), re.x + (re.width / 2), re.y

            + (re.height / 2));

    }

    /**

     * Dibuja el nombre u s?mbolo de la capa que se pasa como par?metro.

     *

     * @param g

     *            Graphics2D sobre el que se dibuja.

     * @param re

     *            Rectangle a rellenar.

     * @param h

     *            Altura en pixels.

     * @param layers

     *            Capa a representar.

     * @param n

     *            ?ndice de la capa a dibujar.

     * @throws ReadDriverException

     *             TODO

     */

    private void drawLegendOrToFFrame(Graphics2D g, Rectangle2D re, double h,

        FLayers layers, int[] n, LayoutContext layout) {

        float sizefont = 0;

        if ((re.getHeight() / m_numLayers) < (re.getWidth() / (m_max * 0.7))) {

            sizefont = (float) (re.getHeight() / m_numLayers);

        } else {

            sizefont = (float) (re.getWidth() / (m_max * 0.7));

        }

        int l = 0;

        // ////Se recorren los layers dibujando el s?mbolo y su nombre sobre el

        // graphics

        for (int i = layers.getLayersCount() - 1; i >= 0; i--) {

            FLayer layer = layers.getLayer(i);

            boolean b = false;

            if (nameLayers.size() > l

                && nameLayers.get(l).equals(layer.getName())) {

                b = ((Boolean) areVisible.get(l)).booleanValue();

            } else {

                b = layer.isVisible();

            }

            l++;

            if (b) {

                if (layer instanceof FLayers) {

                    n[0]++;

                    double dX = 0;

                    double dY = n[0] * h;

                    double xl = (re.getX() + dX);

                    double yl = (re.getY() + dY);

                    if (layout != null) {

                        toFFrameText(layout, layer.getName(), re, sizefont,

                            (xl - (re.getWidth() / 5)), yl, h);

                    } else {

                        drawNameLegend(g, layer.getName(), re, sizefont,

                            (xl - (re.getWidth() / 5)), yl, h);

                    }

                    n[0]++;

                    drawLegendOrToFFrame(g, re, h, (FLayers) layer, n, layout);

                    n[0]++;

                } else

                    if (layer instanceof Classifiable

                        && !(layer instanceof IHasImageLegend)) {

                        Classifiable cO = (Classifiable) layer;

                        if (cO.getLegend() instanceof IClassifiedLegend) {// &&

                                                                          // !(cO

                                                                          // instanceof

                                                                          // FLyrAnnotation))

                                                                          // {

                            IClassifiedLegend cli =

                                (IClassifiedLegend) cO.getLegend();

                            double dX = 0;

                            double dY = n[0] * h;

                            double xl = (re.getX() + dX);

                            double yl = (re.getY() + dY);

                            if (layout != null) {

                                toFFrameText(layout, layer.getName(), re,

                                    sizefont, (xl - (re.getWidth() / 5)), yl, h);

                            } else {

                                drawNameLegend(g, layer.getName(), re,

                                    sizefont, (xl - (re.getWidth() / 5)), yl, h);

                            }

                            n[0]++;

                            String[] descriptions = cli.getDescriptions();

                            ISymbol[] symbols = cli.getSymbols();

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

                                dY = n[0] * h;

                                xl = (re.getX() + dX);

                                yl = (re.getY() + dY);

                                String s = descriptions[j];

                                if (layout != null) {

                                    toFFrameText(layout, s, re, sizefont, xl,

                                        yl, h);

                                } else {

                                    drawNameLegend(g, s, re, sizefont, xl, yl,

                                        h);

                                }

                                ISymbol fs2d = symbols[j];

                                if (layout != null) {

                                    try {

                                        toFFrameSymbol(layout, re, xl, yl,

                                            fs2d, sizefont, h,

                                            cO.getShapeType());

                                    } catch (ReadException e) {

                                        e.printStackTrace();

                                    }

                                } else {

                                    drawSymbolLegend(g, re, xl, yl, fs2d,

                                        sizefont, h);

                                }

                                n[0]++;

                            }

                        } else {

                            double dX = 0;

                            double dY = n[0] * h;

                            double xl = (re.getX() + dX);

                            double yl = (re.getY() + dY);

                            if (layout != null) {

                                toFFrameText(layout, layer.getName(), re,

                                    sizefont, xl, yl, h);

                            } else {

                                drawNameLegend(g, layer.getName(), re,

                                    sizefont, xl, yl, h);

                            }

                            // TO DO: CAMBIAR TO_DO ESTO PARA QUE ACEPTE ISYMBOL

                            // TODO: comprovar que no es trenca res

                            if (cO.getLegend() != null) {

                                ISymbol fs2d =

                                    cO.getLegend().getDefaultSymbol();

                                if (layout != null) {

                                    try {

                                        toFFrameSymbol(layout, re, xl, yl,

                                            fs2d, sizefont, h,

                                            cO.getShapeType());

                                    } catch (ReadException e) {

                                        e.printStackTrace();

                                    }

                                } else {

                                    drawSymbolLegend(g, re, xl, yl, fs2d,

                                        sizefont, h);

                                }

                            }

                            n[0]++;

                        }

                    } else

                        if (layer instanceof IHasImageLegend) {

                            Image image =

                                ((IHasImageLegend) layer).getImageLegend();

                            String path =

                                ((IHasImageLegend) layer).getPathImage();

                            if (image != null) {

                                FFramePicture picture =

                                    (FFramePicture) layoutManager

                                        .createFrame(FFramePicture.PERSISTENCE_DEFINITION_NAME);

                                BufferedImage bi =

                                    new BufferedImage(image.getWidth(null),

                                        image.getHeight(null),

                                        BufferedImage.TYPE_INT_ARGB);

                                Graphics2D biContext = bi.createGraphics();

                                biContext.drawImage(image, 0, 0, null);

                                picture.setImage(bi);

                                double dY = n[0] * h;

                                Rectangle2D rectImage =

                                    new Rectangle2D.Double(re.getX(), re.getY()

                                        + dY, re.getWidth(), h);

                                if (layout != null) {

                                    picture

                                        .setBoundBox(FLayoutUtilities

                                            .toSheetRect(rectImage,

                                                layout.getAT()));

                                    picture.setPath(path);

                                    layout.addFFrame(picture, false, true);

                                } else {

                                    picture.setBoundBox(FLayoutUtilities

                                        .toSheetRect(rectImage,

                                            new AffineTransform()));

                                    picture.draw(g, new AffineTransform(), re,

                                        bi);

                                }

                            }

                            n[0]++;

                        } else {

                            double dX = 0;

                            double dY = n[0] * h;

                            double xl = (re.getX() + dX);

                            double yl = (re.getY() + dY);

                            if (layout != null) {

                                toFFrameText(layout, layer.getName(), re,

                                    sizefont, xl, yl, h);

                            } else {

                                drawNameLegend(g, layer.getName(), re,

                                    sizefont, xl, yl, h);

                            }

                            n[0]++;

                        }

            }

        }

    }

    /**

     * Dibuja sobre el graphics el nombre de la capa que se pasa como

     * par?metro.

     *

     * @param g

     *            Graphics2D sobre el que dibujar.

     * @param name

     *            Nombre de la capa.

     * @param re

     *            Rect?ngulo a ocupar por el nombre.

     * @param sizefont

     *            tama?o de la fuente.

     * @param x

     *            Posici?n X.

     * @param y

     *            Posici?n Y.

     * @param h

     *            Altura.

     */

    private void drawNameLegend(Graphics2D g, String name, Rectangle2D re,

        float sizefont, double x, double y, double h) {

        Font f = getFont(sizefont);

        g.setFont(f);

        g.setColor(Color.black);

        if (name != null)

            g.drawString(name, (float) (x + (re.getWidth() / 4)),

                (float) (y + (h / 2)));

    }

    private Font getFont(float sizefont) {

        Font f = getFont();

        return new Font(f.getName(), f.getStyle(), (int) sizefont);

    }

    /**

     * A?ade al Layout un nuevo FFrameText a partir de los par?metros de

     * entrada.

     *

     * @param layout

     *            Layout sobre el que se crea el nuevo FFrame.

     * @param name

     *            Texto.

     * @param sizefont

     *            tama?o de la fuente.

     * @param x

     *            Posici?n X.

     * @param y

     *            Posici?n Y.

     * @param h

     *            Altura.

     * @param wT

     *            Rect?ngulo del FFrame.

     * @param hT

     *            DOCUMENT ME!

     */

    private void toFFrameText(LayoutContext layout, String name,

        Rectangle2D re, float sizefont, double x, double y, double h) {

        // Font f = getFont(sizefont);

        Rectangle2D rAux =

            new Rectangle2D.Double(x + re.getWidth() / 4, ((y + (h / 2)) - h),

                re.getWidth() - re.getWidth() / 4, h);

        FFrameText text =

            (FFrameText) layoutManager

                .createFrame(FFrameText.PERSISTENCE_DEFINITION_NAME);

        text.setFixedFontSize(true);

        double myScale = layout.getAT().getScaleX() * 0.0234;

        text.setFontSize((int) (sizefont / myScale));

        text.setBoundBox(FLayoutUtilities.toSheetRect(rAux, layout.getAT()));

        text.addText(name);

        layout.addFFrame(text, false, true);

    }

    /**

     * Dibuja sobre el Graphics2D el s?mbolo.

     *

     * @param g

     *            Graphics2D.

     * @param re

     *            Rect?ngulo a cubrir por el s?mbolo.

     * @param x

     *            Posici?n X.

     * @param y

     *            Posici?n Y.

     * @param symbol2d

     *            S?mbolo a dibujar.

     * @param sizefont

     *            Tama?o de la fuente.

     * @param h

     *            Altura.

     */

    private void drawSymbolLegend(Graphics2D g, Rectangle2D re, double x,

        double y, ISymbol symbol2d, float sizefont, double h) {

        double pW = 5;

        double wl = (re.getWidth() / pW);

        double haux = (sizefont * 0.7);

        Font font = null;

        if (symbol2d instanceof ITextSymbol

            && (font = ((ITextSymbol) symbol2d).getFont()) != null) {

            ((ITextSymbol) symbol2d).setFont(new Font(font.getFontName(), font

                .getStyle(), (int) (wl / 6)));

        }

        Rectangle rectangle =

            new Rectangle((int) x, (int) ((y + (h / 2)) - haux), (int) wl,

                (int) haux);

        try {

            symbol2d.drawInsideRectangle(g, new AffineTransform(), rectangle,

                properties);

        } catch (SymbolDrawingException e) {

            if (e.getType() == SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS) {

                try {

                    mapContextManager

                        .getSymbolManager()

                        .getWarningSymbol(

                            SymbolDrawingException.STR_UNSUPPORTED_SET_OF_SETTINGS,

                            symbol2d.getDescription(),

                            SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS)

                        .drawInsideRectangle(g, null, rectangle, null);

                } catch (SymbolDrawingException e1) {

                    // IMPOSSIBLE TO REACH THIS

                }

            } else {

                // should be unreachable code

                throw new Error(PluginServices.getText(this,

                    "symbol_shapetype_mismatch"));

            }

        }

    }

    /**

     * A?ade al Layout un nuevo FFrameSymbol.

     *

     * @param layout

     *            Layout sobe el que se a?ade el FFrame.

     * @param x

     *            Posici?n X.

     * @param y

     *            Posici?n Y.

     * @param fs2d

     *            S?mbolo a a?adir.

     * @param h

     *            Altura.

     * @param shapeType

     * @param wT

     *            Rect?ngulo del FFrame.

     * @param hT

     *            tama?o de la fuente.

     */

    private void toFFrameSymbol(LayoutContext layout, Rectangle2D re, double x,

        double y, ISymbol fs2d, float sizefont, double h, int shapeType) {

        double pW = 5;

        double wl = (re.getWidth() / pW);

        double haux = (sizefont * 0.7);

        Font font = null;

        if (fs2d instanceof ITextSymbol

            && (font = ((ITextSymbol) fs2d).getFont()) != null) {

            ((ITextSymbol) fs2d).setFont(new Font(font.getFontName(), font

                .getStyle(), (int) (wl / 6)));

        }

        Rectangle2D rAux3 =

            new Rectangle2D.Double(x, ((y + (h / 2)) - haux), wl, haux);

        FFrameSymbol symbol =

            (FFrameSymbol) layoutManager

                .createFrame(FFrameSymbol.PERSISTENCE_DEFINITION_NAME);

        // symbol.setLayout(getLayout());

        symbol.setBoundBox(FLayoutUtilities.toSheetRect(rAux3, layout.getAT()));

        symbol.setSymbol(fs2d);

        symbol.setShapeType(shapeType);

        layout.addFFrame(symbol, false, true);

    }

    /**

     * Devuelve el n?mero total de capas incluyendo las subcapas.

     *

     * @param layers

     *            Capa a contar.

     *

     * @return N?mero de capas y subcapas.

     */

    private int getSizeNum(FLayers layers) {

        int n = 0;

        // ///Aqu? hay que calcular cuantos layers y sublayers hay, para saber

        // que distancias dejar entre uno y otro.

        // /y adem?s el tama?o de cada uno de ellos para saber que anchura

        // dejar.

        int l = 0;

        for (int i = layers.getLayersCount() - 1; i >= 0; i--) {

            FLayer layer = layers.getLayer(i);

            boolean b = false;

            if (nameLayers.size() > l

                && nameLayers.get(l).equals(layer.getName())) {

                b = ((Boolean) areVisible.get(l)).booleanValue();

            } else {

                b = layer.isVisible();

            }

            l++;

            if (b) {

                // if (layer.isVisible()) {

                if (layer.getName().length() > m_max) {

                    m_max = layer.getName().length();

                }

                if (layer instanceof FLayers) {

                    // n++;

                    n = n + 3;

                    n += getSizeNum((FLayers) layer); // m_numLayers +=

                                                      // getNumInLyrGroup((FLayers)

                                                      // layer);

                } else {

                    if (layer instanceof Classifiable) {

                        Classifiable cO = (Classifiable) layer;

                        n++;

                        if (cO.getLegend() instanceof IClassifiedLegend) {// &&

                                                                          // !(cO

                                                                          // instanceof

                                                                          // FLyrAnnotation))

                                                                          // {

                            IClassifiedLegend cli =

                                (IClassifiedLegend) cO.getLegend();

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

                                String s = cli.getDescriptions()[j];

                                if (s != null && s.length() > m_max) {

                                    m_max = s.length();

                                }

                                n++;

                            }

                        }

                    } else {

                        String s = layer.getName();

                        if (s != null && s.length() > m_max) {

                            m_max = s.length();

                        }

                        n++;

                    }

                }

            }

        }

        return n;

    }

    /**

     * Transforma el FFrameLegend en diferentes FFrameSymbol y FFrameText.

     *

     * @param layout

     *            Layout sobre el que a?adir los FFrame nuevos y sobre el

     *            que elimnar el FFrameLegend anterior.

     */

    public void toFFrames(LayoutContext layout) {

        Rectangle2D rectangle = getBoundingBox(null);

        double h = rectangle.getHeight() / m_numLayers;

        FLayers lays = layers;

        // layout.getEFS().startComplexCommand();

        // toFFrames(layout, lays, rectangle, r.getWidth(), r.getHeight(), h,

        // 0);

        int[] n = new int[1];

        n[0] = 0;

        drawLegendOrToFFrame(null, rectangle, h, lays, n, layout);

        layout.delFFrame(this);

        // /layout.getFFrames().remove(this);

        // layout.getEFS().endComplexCommand();

    }

    /**

     * Rellena la fuente a utilizar al dibujar los String sobre el graphics.

     *

     * @param f

     *            Font.

     */

    public void setFont(Font f) {

        m_font = f;

    }

    /**

     * Devuelve la fuente que esta utilizando.

     *

     * @return Font.

     */

    public Font getFont() {

        if (m_font != null) {

            return new Font(m_font.getName(), m_font.getStyle(), 9);

        }

        return new Font("SansSerif", Font.PLAIN, 9);

    }

    public String getNameFFrame() {

        return PluginServices.getText(this, "leyenda") + num;

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    public void print(Graphics2D g, AffineTransform at, Geometry geom,

        PrintAttributes properties) {

        this.properties = properties;

        draw(g, at, null, null);

        this.properties = null;

    }

    public void initialize() {

    }

    public void setNameLayers(List nameLayers) {

        this.nameLayers = nameLayers;

    }

    public void setAreVisible(List areVisible) {

        this.areVisible = areVisible;

    }

    public List getNameLayers() {

        return nameLayers;

    }

    public List getAreVisible() {

        return areVisible;

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(FFrameLegend.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameLegend persistence definition", null, null);

            definition

                .extend(manager

                    .getDefinition(AbstractFFrameViewDependence.PERSISTENCE_DEFINITION_NAME));

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

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

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

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

            definition.addDynFieldObject(FONT_FIELD)

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

            definition.addDynFieldList(NAMELAYERS_FIELD)

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

            definition.addDynFieldList(AREVISIBLE_FIELD)

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

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        m_numLayers = state.getInt(NUMLAYERS_FIELD);

        m_max = state.getInt(MAX_FIELD);

        m_quality = state.getInt(QUALITY_FIELD);

        m_viewing = state.getInt(VIEWING_FIELD);

        m_font = (Font) state.get(FONT_FIELD);

        nameLayers = (List<String>) state.getList(NAMELAYERS_FIELD);

        areVisible = (List<Boolean>) state.getList(AREVISIBLE_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(NUMLAYERS_FIELD, m_numLayers);

        state.set(MAX_FIELD, m_max);

        state.set(QUALITY_FIELD, m_quality);

        state.set(VIEWING_FIELD, m_viewing);

        state.set(FONT_FIELD, m_font);

        state.set(NAMELAYERS_FIELD, nameLayers);

        state.set(AREVISIBLE_FIELD, areVisible);

    }

}