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

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.font.FontRenderContext;

import java.awt.font.TextLayout;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.collections4.ListUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginServices;

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

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

import org.gvsig.app.project.documents.layout.report.LayoutReportActionImpl;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.future.FutureUtils;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * FFrame para introducir un texto en el Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameText extends FFrame {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameText";

    private static final String TEXT_FIELD = "text";

    private static final String S_FIELD = "s";

    private static final String ISFIXED_FIELD = "isFixed";

    private static final String FONT_FIELD = "font";

    private static final String POS_FIELD = "pos";

    private static final String TEXTCOLOR_FIELD = "textColor";

    private static final String TRANSITIONPIXELSMILIMETERS_FIELD =

        "transicionPixelsMilimetros";

    private static final String CELLPADDING_FIELD = "cellPadding";

    private static final String FONTSIZE_FIELD = "fontSize";

    private static final String FIXEDFONTSIZE_FIELD = "fixedFontSize";

    private static final String SURROUNDED_FIELD = "surrounded";

    private static final String HASTITLE_FIELD = "hasTitle";

    private static final String TITLE_FIELD = "title";

    private static final String TITLESIZE_FIELD = "titleSize";

    private static final String FRAMEBORDERSIZE_FIELD = "frameBorderSize";

    private static final String FRAMECOLOR_FIELD = "frameColor";

    private static final String TITLECOLOR_FIELD = "titleColor";

    /** Localizaci?n del texto. */

    public static final int LEFT = 0;

    public static final int CENTER = 1;

    public static final int RIGTH = 2;

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

    private boolean m_isFixed = false;

    private int m_pos = LEFT;

    private Color textColor = Color.BLACK;

    // jaume

    private boolean surrounded = false; // The text field is surrounded by a

                                        // rectangle

    private double cellPadding = 0; // The gap between the the text field and

                                    // the surrounding rectangle

    private boolean fixedFontSize = false; // The text field font size is

                                           // constant fixed to the folio's size

    private int fontSize; // Text field's font size

    private boolean hasTitle; // The text field has title

    private String title; // The text for the title

    private int titleSize; // The title's font size

    private double frameBorderSize = 0; // The surrounding rectangle's border

                                        // size

    private Color frameColor = Color.BLACK; // The surrounding rectangle's color

    private Color titleColor = Color.BLACK; // The title's color

    private Font m_f = null;

    private boolean transicionPixelsMilimetros = true;

    /**

     * Crea un nuevo FFrameText.

     */

    public FFrameText() {

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

    }

    /**

     * Inserta la fuente del texto.

     * 

     * @param f

     *            Fuente del texto.

     */

    public void setFont(Font f) {

        m_f = f;

    }

    /**

     * Devuelve el color del texto del FFrameText.

     * 

     * @return Color del texto.

     */

    public Color getTextColor() {

        return textColor;

    }

    /**

     * Obtiene el fixedFontSize

     * 

     * @return boolean

     */

    public boolean isFontSizeFixed() {

        return fixedFontSize;

    }

    /**

     * Establece fixedFontSize

     * 

     * @param fixedFontSize

     */

    public void setFixedFontSize(boolean fixedFontSize) {

        this.fixedFontSize = fixedFontSize;

    }

    /**

     * Obtiene el fontSize

     * 

     * @return int

     */

    public int getFontSize() {

        return fontSize;

    }

    /**

     * Establece fontSize

     * 

     * @param fontSize

     */

    public void setFontSize(int fontSize) {

        this.fontSize = fontSize;

    }

    /**

     * Obtiene el cellPadding

     * 

     * @return int

     */

    public double getCellPadding() {

        return cellPadding;

    }

    /**

     * Inserta el color del texto a escribir.

     * 

     * @param color

     *            Color del texto.

     */

    public void setTextColor(Color color) {

        textColor = color;

    }

    /**

     * Devuelve la fuente del texto.

     * 

     * @return Fuente del texto.

     */

    public Font getFont() {

        return new Font(m_f.getFontName(), m_f.getStyle(), 9);

    }

    /**

     * Devuelve la posici?n izquierda, centro o derecha del texto.

     * 

     * @return Posici?n del texto.

     */

    public int getPos() {

        return m_pos;

    }

    /**

     * Pone la posici?n izquierda, centro o derecha del texto.

     * 

     * @param p

     *            0=LEFT,1=CENTER,2=RIGTH.

     */

    public void setPos(int p) {

        m_pos = p;

    }

    /**

     * 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 af?n.

     * @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) {

        g.setColor(Color.BLACK);

        Rectangle2D.Double rec = getBoundingBox(at);

        Rectangle2D.Double raux = (Rectangle2D.Double) rec.clone();

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

            raux.y + (raux.height / 2));

        int longmax = 1;

        if (intersects(rv, raux)) { // comprueba que no cae fuera de la pantalla

            List<String> texts = this.getExpandedTexts();

            if ( CollectionUtils.isEmpty(texts) ) {

                drawEmpty(g);

            } else {

                for (String text : texts) {

                    if( text == null) {

                        text = "<NULL>";

                    }

                    if (text.length() > longmax) {

                        longmax = text.length();

                    }

                }

                FontRenderContext frc = g.getFontRenderContext();

                int scaledFontSize;

                // TODO myScale es la escala sobre la que se extraen todos los

                // escalados. Esto

                // funciona bien tal cual est? si la ratio de aspecto

                // (alto/ancho) del folio es constante

                // porque se toma como medidas el ancho del folio real y el

                // ancho del folio en pantalla.

                // No se que pasar? si la ratio cambia, por ejemplo si se usan

                // USLetter en lugar de DIN A4

                double myScale = at.getScaleX() * 0.0234; // FLayoutUtilities.fromSheetDistance(folio.getAncho(),at)/rv.getWidth();

                // Distinguish when the font has fixed size or not

                if (isFontSizeFixed()) {

                    scaledFontSize = (int) (myScale * fontSize);

                } else {

                    scaledFontSize = ((int) (raux.width)) / longmax;

                    if (scaledFontSize > (int) ((raux.height) / texts.size())) {

                        scaledFontSize = (int) ((raux.height) / texts.size());

                    }

                }

                if (m_f != null) {

                    // Aqu? se ajusta a partir de las caracter?sticas de la

                    // fuente, una nueva fuente con el tama?o ajustado.

                    m_f =

                        new Font(m_f.getFontName(), m_f.getStyle(),

                            scaledFontSize);

                } else {

                    // Aqu? pasa cuando se abre el di?logo para seleccionar un

                    // tipo de fuente y se cierra sin haber seleccionado

                    // ninguna.

                    m_f = new Font("SansSerif", Font.PLAIN, scaledFontSize);

                }

                // Draw the text title if it exists

                if (hasTitle()) {

                    int scaledTitleFontSize = (int) (myScale * titleSize);

                    int gap = 3;

                    if (isSurrounded()) {

                        // Para evitar que el marco se pinte sobre el t?tulo

                        gap +=

                            (int) (FLayoutUtilities.fromSheetDistance(

                                frameBorderSize, at) * myScale);

                    }

                    g.setColor(titleColor);

                    Font titleFont =

                        new Font(m_f.getFontName(), m_f.getStyle(),

                            scaledTitleFontSize);

                    if (!getTitle().equals("")) {

                        TextLayout titleTextLayout =

                            new TextLayout(getTitle(), titleFont, frc);

                        titleTextLayout.draw(g, (float) raux.getX(),

                            (float) (raux.getY() - (gap * myScale)));

                    }

                }

                // Draw the frame involving the text if it exists

                if (isSurrounded()) {

                    g.setColor(frameColor);

                    // g.drawRect((int) raux.x, (int) raux.y, (int) raux.width,

                    // (int) raux.height);

                    double scaledCellPadding =

                        FLayoutUtilities.fromSheetDistance(cellPadding, at);

                    double sizeBorder =

                        FLayoutUtilities.fromSheetDistance(frameBorderSize, at);

                    // if (sizeBorder > 1) {

                    int bordermm = (int) (sizeBorder * 10);

                    int scaledCellPaddingmm = (int) (scaledCellPadding * 10);

                    // System.out.println("borderSize = " + bordermm);

                    g.setStroke(new BasicStroke(bordermm));

                    // int scaledBorderSize = (int) (sizeBorder * myScale);

                    // for (int i = scaledBorderSize - 1; i > 0; i--)

                    // g.drawRect((int) raux.x - i, (int) raux.y - i,

                    // (int) raux.width + (2 * i),

                    // (int) raux.height + (2 * i));

                    g.drawRect((int) (raux.x + bordermm / 2 - 1), (int) (raux.y

                        + bordermm / 2 - 1), (int) (raux.width - bordermm + 2),

                        (int) (raux.height - bordermm + 2));

                    g.setStroke(new BasicStroke(0));

                    // }

                    // Recalibro el rectangulo para establecer el ?rea donde se

                    // dibujan las fuentes

                    // al ?rea marcada con el rat?n menos la distancia al marco

                    // especificada

                    raux.setRect(raux.getX() + scaledCellPaddingmm + bordermm,

                        raux.getY() + scaledCellPaddingmm + bordermm,

                        raux.getWidth() - (scaledCellPaddingmm * 2) - bordermm

                            * 2, raux.getHeight() - (scaledCellPaddingmm * 2)

                            - bordermm * 2);

                    if (raux.getWidth() <= 0 || raux.getHeight() <= 0) {

                        // JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this,"too_large_border")+": "+bordermm+

                        // " + "+scaledCellPaddingmm);

                        g.setColor(Color.red);

                        drawError(getBoundingBox(at), 15, g,

                            PluginServices.getText(this, "too_large_border")

                                + ": " + frameBorderSize + "cm + "

                                + cellPadding + "cm");

                        // g.rotate(Math.toRadians(-getRotation()),

                        // raux.x + (raux.width / 2), raux.y + (raux.height /

                        // 2));

                        return;

                    }

                }

                g.setColor(textColor);

                drawText(raux, scaledFontSize, g);

                g.rotate(Math.toRadians(-getRotation()), raux.x

                    + (raux.width / 2), raux.y + (raux.height / 2));

            }

        }

        raux = null;

    }

    private void drawError(Rectangle2D r, int sfs, Graphics2D g, String error) {

        FontRenderContext frc = g.getFontRenderContext();

        TextLayout textLayout = null;

        m_f = new Font(m_f.getFontName(), m_f.getStyle(), sfs);

        textLayout = new TextLayout(error, m_f, frc);

        textLayout.draw(g, (float) r.getCenterX(), (float) (r.getCenterY()));

    }

    /**

     * Dibuja el texto sobre el graphics con el tama?o adecuado.

     * 

     * @param r

     *            Rect?ngulo sobre el que dibujar.

     * @param sfs

     *            Tama?o aproximado del texto.

     * @param g

     *            Graphics sobre el que dibujar el texto.

     */

    private void drawText(Rectangle2D r, int sfs, Graphics2D g) {

        int minSFS = Integer.MAX_VALUE;

        FontRenderContext frc = g.getFontRenderContext();

        List<String> texts = this.getExpandedTexts();

        int ht = (int) (r.getHeight() / texts.size());

        if (isFontSizeFixed()) {

            minSFS = sfs;

        } else {

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

                if (!texts.get(i).equals("") && !texts.get(i).equals("\n")) {

                    TextLayout textaux = new TextLayout(texts.get(i), m_f, frc);

                    Rectangle2D txtBound = textaux.getBounds();

                    double difW = txtBound.getWidth() / r.getWidth();

                    double difH = (txtBound.getHeight() * texts.size()) / (r.getHeight());

                    if (difW > difH) {

                        if (minSFS > sfs) {

                            minSFS = (int) (sfs / difW);

                        }

                    } else {

                        if (minSFS > sfs) {

                            minSFS = (int) (sfs / difH);

                        }

                    }

                }

            }

        }

        TextLayout textLayout = null;

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

            if (!texts.get(i).equals("")) {

                m_f = new Font(m_f.getFontName(), m_f.getStyle(), minSFS);

                textLayout = new TextLayout(texts.get(i), m_f, frc);

                Rectangle2D txtBound = textLayout.getBounds();

                float difW = (float) (r.getWidth() - txtBound.getWidth());

                switch (m_pos) {

                case (LEFT):

                    textLayout.draw(g, (float) r.getX(),

                        (float) (r.getY() + (ht * (i + 0.8))));

                    break;

                case (CENTER):

                    textLayout.draw(g, (float) r.getX() + (difW / 2),

                        (float) (r.getY() + (ht * (i + 0.8))));

                    break;

                case (RIGTH):

                    textLayout.draw(g, (float) r.getX() + difW,

                        (float) (r.getY() + (ht * (i + 0.8)))); // - (ht /

                                                                // 2))));

                    break;

                }

            }

        }

    }

    /*

     * @see

     * com.iver.cit.gvsig.project.documents.layout.fframes.IFFrame#print(java

     * .awt.Graphics2D,

     * java.awt.geom.AffineTransform)

     */

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

        PrintAttributes properties) {

        draw(g, at, null, null);

    }

    /**

     * Rellenar el texto que se quiere a?adir al Layout.

     * 

     * @param s

     *            String a a?adir.

     */

    public void addText(String s) {

        m_text.add(s);

    }

    /**

     * Devuelve el ArrayList que contiene las l?neas de texto.

     * 

     * @return ArrayList.

     */

    public List<String> getText() {

        return m_text;

    }

    /**

     * Seleccionar si se quiere un tama?o fijo o adecuado a la escala.

     * 

     * @param b

     *            true si se quiere tama?o fijo.

     */

    public void setSizeFixed(boolean b) {

        m_isFixed = b;

    }

    /**

     * Devuelve si est? fijado el tama?o.

     * 

     * @return True si est? fijado el tama?o.

     */

    public boolean isSizeFixed() {

        return m_isFixed;

    }

    /**

     * @see org.gvsig.app.project.documents.layout.fframes.IFFrame#getNameFFrame()

     */

    public String getNameFFrame() {

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

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    /**

     * Sets FFrameText to draw an involving rectangle

     * 

     * @param b

     */

    public void setSurrounded(boolean b) {

        surrounded = b;

    }

    /**

     * True if the FFrameText is set to draw an involving rectangle, or false

     * if not.

     * 

     * @return boolean

     */

    public boolean isSurrounded() {

        return surrounded;

    }

    /**

     * Sets the gap between the involving rectangle and the text

     * 

     * @param i

     */

    public void setCellPadding(double i) {

        cellPadding = i;

    }

    /**

     * Devuelve true si tiene un t?tulo.

     * 

     * @return

     */

    public boolean hasTitle() {

        return hasTitle;

    }

    /**

     * Devuelve un string con el t?tulo.

     * 

     * @return

     */

    public String getTitle() {

        return title;

    }

    /**

     * Inserta true si tiene t?tulo

     * 

     * @param b

     */

    public void setHasTitle(boolean b) {

        hasTitle = b;

    }

    /**

     * Inserta un string con el t?tulo.

     * 

     * @param text

     */

    public void setTitle(String text) {

        title = text;

    }

    /**

     * Devuelve el tama?o del t?tulo.

     * 

     * @return

     */

    public int getTitleSize() {

        return titleSize;

    }

    /**

     * Inserta el tama?o del t?tulo.

     * 

     * @param size

     *            DOCUMENT ME!

     */

    public void setTitleSize(int size) {

        titleSize = size;

    }

    /**

     * Inserta el tama?o del borde.

     * 

     * @param size

     */

    public void setFrameBorderSize(double size) {

        frameBorderSize = size;

    }

    /**

     * Devuelve el tama?o del borde.

     * 

     * @return

     */

    public double getFrameBorderSize() {

        return frameBorderSize;

    }

    /**

     * DOCUMENT ME!

     * 

     * @param frameColor

     */

    public void setFrameColor(Color frameColor) {

        this.frameColor = frameColor;

    }

    /**

     * DOCUMENT ME!

     * 

     * @param titleColor

     *            DOCUMENT ME!

     */

    public void setTitleColor(Color titleColor) {

        this.titleColor = titleColor;

    }

    /**

     * DOCUMENT ME!

     * 

     * @return DOCUMENT ME!

     */

    public Color getFrameColor() {

        return frameColor;

    }

    /**

     * DOCUMENT ME!

     * 

     * @return DOCUMENT ME!

     */

    public Color getTitleColor() {

        return titleColor;

    }

    /**

     * Use this method if you want the text in the FFrameText to be removed.

     */

    public void clearText() {

        m_text.clear();

    }

    public void initialize() {

        // TODO Auto-generated method stub

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(FFrameText.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameText persistence definition", null, null);

            definition.extend(manager

                .getDefinition(FFrame.PERSISTENCE_DEFINITION_NAME));

            /*

             * field 's' is Rectangle but stored as Rectangle2D

             */

            definition.addDynFieldObject(S_FIELD)

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

            definition.addDynFieldList(TEXT_FIELD)

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

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

            definition.addDynFieldObject(FONT_FIELD)

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

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

            definition.addDynFieldObject(TEXTCOLOR_FIELD)

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

            definition.addDynFieldBoolean(TRANSITIONPIXELSMILIMETERS_FIELD)

                .setMandatory(true);

            definition.addDynFieldDouble(CELLPADDING_FIELD).setMandatory(false);

            definition.addDynFieldInt(FONTSIZE_FIELD).setMandatory(false);

            definition.addDynFieldBoolean(FIXEDFONTSIZE_FIELD).setMandatory(

                false);

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

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

            definition.addDynFieldString(TITLE_FIELD).setMandatory(false);

            definition.addDynFieldInt(TITLESIZE_FIELD).setMandatory(false);

            definition.addDynFieldDouble(FRAMEBORDERSIZE_FIELD).setMandatory(

                false);

            definition.addDynFieldObject(FRAMECOLOR_FIELD)

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

            definition.addDynFieldObject(TITLECOLOR_FIELD)

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

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        /*

         * field 's' is Rectangle but stored as Rectangle2D

         */

        Rectangle2D s_2d = (Rectangle2D) state.get(S_FIELD);

        s = new Rectangle(

            (int) s_2d.getX(),

            (int) s_2d.getY(),

            (int) s_2d.getWidth(),

            (int) s_2d.getHeight());

        /*

         * the text is an arraylist of strings

         */

        List<String> text_list = state.getList(TEXT_FIELD);

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

            m_text.add(text_list.get(i));

        }

        m_isFixed = state.getBoolean(ISFIXED_FIELD);

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

        m_pos = state.getInt(POS_FIELD);

        textColor = (Color) state.get(TEXTCOLOR_FIELD);

        transicionPixelsMilimetros =

            state.getBoolean(TRANSITIONPIXELSMILIMETERS_FIELD);

        cellPadding = state.getDouble(CELLPADDING_FIELD);

        fontSize = state.getInt(FONTSIZE_FIELD);

        fixedFontSize = state.getBoolean(FIXEDFONTSIZE_FIELD);

        surrounded = state.getBoolean(SURROUNDED_FIELD);

        hasTitle = state.getBoolean(HASTITLE_FIELD);

        title = state.getString(TITLE_FIELD);

        titleSize = state.getInt(TITLESIZE_FIELD);

        frameBorderSize = state.getDouble(FRAMEBORDERSIZE_FIELD);

        frameColor = (Color) state.get(FRAMECOLOR_FIELD);

        titleColor = (Color) state.get(TITLECOLOR_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        /*

         * field 's' is Rectangle but stored as Rectangle2D

         */

        Rectangle2D s_2d = new Rectangle2D.Double(

            s.x, s.y, s.width, s.height);

        state.set(S_FIELD, s_2d);

        state.set(TEXT_FIELD, m_text);

        state.set(ISFIXED_FIELD, m_isFixed);

        state.set(FONT_FIELD, m_f);

        state.set(POS_FIELD, m_pos);

        state.set(TEXTCOLOR_FIELD, textColor);

        state.set(TRANSITIONPIXELSMILIMETERS_FIELD, transicionPixelsMilimetros);

        state.set(CELLPADDING_FIELD, cellPadding);

        state.set(FONTSIZE_FIELD, fontSize);

        state.set(FIXEDFONTSIZE_FIELD, fixedFontSize);

        state.set(SURROUNDED_FIELD, surrounded);

        state.set(HASTITLE_FIELD, hasTitle);

        state.set(TITLE_FIELD, title);

        state.set(TITLESIZE_FIELD, titleSize);

        state.set(FRAMEBORDERSIZE_FIELD, frameBorderSize);

        state.set(FRAMECOLOR_FIELD, frameColor);

        state.set(TITLECOLOR_FIELD, titleColor);

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

            FFrameText frame = (FFrameText) super.clone();

            frame.m_text = new ArrayList<>(this.m_text);

            return frame;

    }

    private List<String> getExpandedTexts() {

        try {

            ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

            String ss1 = StringUtils.join(this.m_text, "\n");

            if( !expressionManager.isDynamicText(ss1) ) {

                return this.m_text;

            }

            Document doc = this.getDocument();

            LayoutReportActionImpl report = (LayoutReportActionImpl) doc.getProperty("$REPORT");

            if( report == null ) {

                report = LayoutReportActionImpl.createFakeLayoutReportAction(doc);

            }

            String ss2 = report.evaluateDynamicText(ss1);

            List<String> texts = Arrays.asList(StringUtils.split(ss2, '\n'));

            return texts;

        } catch(Throwable t) {

            return this.m_text;

        }

    }

}