Application: gvSIG desktop » gvSIG Document Layout

/*

 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license

 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template

 */

package org.gvsig.layout.mapbox.model;

import java.awt.Rectangle;

import java.awt.geom.Dimension2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.apache.commons.math.util.MathUtils;

import static org.gvsig.layout.mapbox.fframe.FFrameMapBox.MAPBOX_EPSILON;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.lang.CloneableUtils;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.util.IsEmpty;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public class MapBoxModel implements IsEmpty, Persistent, org.gvsig.tools.lang.Cloneable {

    private static final Logger LOGGER = LoggerFactory.getLogger(MapBoxModel.class);

    public static final String PERSISTENCE_DEFINITION_NAME = "MapBoxModel";

    public static final int POSITION_OUT_OF_MAPBOX = -1;

    public static final int POSITION_IN_CELL = 0;

    public static final int POSITION_AT_TOP_OF_CELL = 1;

    public static final int POSITION_AT_BOTOM_OF_CELL = 2;

    public static final int POSITION_ON_LEFT_EDGE_OF_CELL = 3;

    public static final int POSITION_ON_RIGHT_EDGE_OF_CELL = 4;

    private List<Cell> cells;

    private Dimension2D dimension;

    public MapBoxModel() {

        this.cells = new ArrayList<>();

    }

    public MapBoxModel(Dimension2D dimension, int columns, int rows) {

        this();

        this.dimension = dimension;

        double cellWidth = dimension.getWidth()/columns;

        double cellHeight = dimension.getHeight()/rows;

        for (int i = 0; i < columns; i++) {

            for (int j = 0; j < rows; j++) {

                cells.add(new CellImpl(i*cellWidth, j*cellHeight, cellWidth, cellHeight));

            }

        }

    }

    public MapBoxModel(Dimension2D dimension, List<Cell> cells) {

        this();

        this.dimension = dimension;

        for (Cell cell : cells) {

            this.cells.add(cell);

        }

    }

    public Cell getCell(double x, double y) {

        for (Cell cell : cells) {

            if(cell.contains(x, y)){

                return cell;

            }

        }

        return null;

    }

    public List<Cell> getCells() {

        return cells;

    }

    public List<Cell> getCells(Rectangle2D r) {

        List<Cell> res = new ArrayList();

        for (Cell cell : cells) {

            if(cell.isContained(r)) { // || cell.intersects(r)){

                res.add(cell);

            }

        }

        return res;

    }

    public void add(Cell c) {

        this.cells.add(c);

    }

    public void insertRow(Cell cell) {

        try {

            Dimension2D oldDimension = (Dimension2D)(this.dimension.clone());

            double y = cell.getY();

            /* Obtenemos las celdas a las que pertenece la celda del par?metro

                para obtener la altura de la fila que ser? la menor altura

                de todas las de la misma fila

            */

            List<Cell> sameRowCells = getRowCells(y);

            double rowHeight = Double.POSITIVE_INFINITY;

            for (Cell sameRowCell : sameRowCells) {

                if(sameRowCell.getHeight()<rowHeight){

                    rowHeight = sameRowCell.getHeight();

                }

            }

            // Obtenemos todas las celdas que est?n debajo de donde tenemos que a?adir una fila nueva

            List<Cell> nextRowsCells = getNextRowsCells(y);

            // Obtenemos todas las celdas que est?n atravesadas por la l?nea horizontal de donde tenemos que a?adir una fila nueva

            List<Cell> rowTraversedCells = getTraversedRowCells(y);

            List<Cell> visited = new ArrayList<>();

            // A?adimos las celdas de la fila nueva

            for (Cell curCell : sameRowCells) {

                Cell c = curCell.clone();

                c.setY(y);

                c.setHeight(rowHeight);

                this.add(c);

                visited.add(curCell);

            }

            // Movemos las celdas que deben estar debajo de la fila nueva

            for (Cell curCell : nextRowsCells) {

                curCell.setY(curCell.getY() + rowHeight);

                visited.add(curCell);

            }

            // Ampliamos la altura de las celdas que son atravesadas por la l?nea horizontal de donde se ha a?adido la fila nueva

            for (Cell curCell : rowTraversedCells) {

                if(visited.contains(curCell)){

                    continue;

                }

                curCell.setHeight(curCell.getHeight()+ rowHeight);

            }

            this.dimension.setSize(dimension.getWidth(), dimension.getHeight() + rowHeight);

            resize(oldDimension);

        } catch (Exception ex) {

            LOGGER.warn("Can't insert row before cell "+Objects.toString(cell), ex);

        }

    }

    /**

     * Insert a column to the left of the cell column passed as a parameter

     *

     * @param cell

     */

    public void insertColumn(Cell cell) {

        try {

            Dimension2D oldDimension = (Dimension2D)(this.dimension.clone());

            double x = cell.getX();

            /* Obtenemos las celdas de la columna a la que pertenece la celda del par?metro

                para obtener la anchura de la columna que ser? la menor anchura

                de todas las de la misma fila

            */

            List<Cell> sameColumnCells = getColumnCells(x);

            double rowWidth = Double.POSITIVE_INFINITY;

            for (Cell sameColumnCell : sameColumnCells) {

                if(sameColumnCell.getWidth()<rowWidth){

                    rowWidth = sameColumnCell.getWidth();

                }

            }

            // Obtenemos todas las celdas que est?n a la derecha de donde tenemos que a?adir la columna nueva

            List<Cell> nextColumnsCells = getNextColumnsCells(x);

            // Obtenemos todas las celdas que est?n atravesadas por la l?nea vertical de donde tenemos que a?adir la columna nueva

            List<Cell> columnTraversedCells = getTraversedColumnCells(x);

            List<Cell> visited = new ArrayList<>();

            // A?adimos las celdas de la fila nueva

            for (Cell curCell : sameColumnCells) {

                Cell c = (Cell) CloneableUtils.cloneQuietly(curCell);

                c.setX(x);

                c.setWidth(rowWidth);

                this.add(c);

                visited.add(curCell);

            }

            // Movemos las celdas que deben estar a la derecha de la fila nueva

            for (Cell curCell : nextColumnsCells) {

                curCell.setX(curCell.getX() + rowWidth);

                visited.add(curCell);

            }

            // Ampliamos la anchura de las celdas que son atravesadas por la l?nea vertical de donde se ha a?adido la columna nueva

            for (Cell curCell : columnTraversedCells) {

                if(visited.contains(curCell)){

                    continue;

                }

                curCell.setWidth(curCell.getWidth()+ rowWidth);

            }

            this.dimension.setSize(dimension.getWidth()+rowWidth, dimension.getHeight());

            resize(oldDimension);

        } catch (Exception ex) {

            LOGGER.warn("Can't insert column before cell "+Objects.toString(cell), ex);

        }

    }

    /**

     * Adds a row below the row to which the cell passed as a parameter belongs

     * @param cell

     */

    public void addRow(Cell cell) {

        try {

            /* Nos guardamos la dimension del cajetin actual para devolversela al acabar */

            Dimension2D oldDimension = (Dimension2D)(this.dimension.clone());

            /* Obtenemos las celdas  que est?n justo encima de donde tenemos que a?adir una fila nueva

            para obtener la altura de la fila que ser? la menor altura

            de todas las de la misma fila

             */

            double y = cell.getY() + cell.getHeight();

            List<Cell> previousRowCells = getPreviousRowCells(y);

            double rowHeight = Double.POSITIVE_INFINITY;

            for (Cell previousRowCell : previousRowCells) {

                if(previousRowCell.getHeight()<rowHeight){

                    rowHeight = previousRowCell.getHeight();

                }

            }

            // Obtenemos todas las celdas que est?n debajo de donde tenemos que a?adir una fila nueva

            List<Cell> nextRowsCells = getNextRowsCells(y);

            // Obtenemos todas las celdas que est?n atravesadas por la l?nea horizontal de donde tenemos que a?adir una fila nueva

            List<Cell> rowTraversedCells = getTraversedRowCells(y);

            List<Cell> visited = new ArrayList<>();

            // A?adimos las celdas de la fila nueva

            for (Cell curCell : previousRowCells) {

                Cell c = (Cell) CloneableUtils.cloneQuietly(curCell);

                c.setY(y);

                c.setHeight(rowHeight);

                this.add(c);

                visited.add(curCell);

            }

            // Movemos las celdas que deben estar debajo de la fila nueva

            for (Cell curCell : nextRowsCells) {

                if(visited.contains(curCell)){

                    continue;

                }

                curCell.setY(curCell.getY() + rowHeight);

                visited.add(curCell);

            }

            // Ampliamos la altura de las celdas que son atravesadas por la l?nea horizontal de donde se ha a?adido la fila nueva

            for (Cell curCell : rowTraversedCells) {

                if(visited.contains(curCell)){

                    continue;

                }

                curCell.setHeight(curCell.getHeight()+ rowHeight);

            }

            /*Recalculamos la dimension segun la fila a?adida*/

            this.dimension.setSize(dimension.getWidth(), dimension.getHeight() + rowHeight);

            /*Devolvemos la dimension que ten?a el cajet?n de manera proporcionada*/

            resize(oldDimension);

        } catch (Exception ex) {

            LOGGER.warn("Can't add row after cell "+Objects.toString(cell), ex);

        }

    }

    /**

     * Adds a column to the right of the cell column passed as a parameter

     * @param cell

     */

    public void addColumn(Cell cell) {

        try {

            /* Nos guardamos la dimension del cajetin actual para devolversela al acabar */

            Dimension2D oldDimension = (Dimension2D)(this.dimension.clone());

            double x = cell.getX() + cell.getWidth();

            /* Obtenemos las celdas que est?n justo a la izquierda de donde tenemos que a?adir una fila nueva

                para obtener la anchura de la columna que ser? la menor anchura

                de todas las de la misma columna

            */

            List<Cell> previousColumnCells = getPreviousColumnCells(x);

            double columnWidth = Double.POSITIVE_INFINITY;

            for (Cell previousColumnCell : previousColumnCells) {

                if(previousColumnCell.getWidth()<columnWidth){

                    columnWidth = previousColumnCell.getWidth();

                }

            }

            // Obtenemos todas las celdas que est?n a la derecha de donde tenemos que a?adir una fila nueva

            List<Cell> nextColumnsCells = getNextColumnsCells(x);

            // Obtenemos todas las celdas que est?n atravesadas por la l?nea vertical de donde tenemos que a?adir la columna nueva

            List<Cell> columnTraversedCells = getTraversedColumnCells(cell.getX() + cell.getWidth());

            List<Cell> visited = new ArrayList<>();

            // A?adimos las celdas de la columna nueva

            for (Cell curCell : previousColumnCells) {

                Cell c = (Cell) CloneableUtils.cloneQuietly(curCell);

                c.setX(x);

                c.setWidth(columnWidth);

                this.add(c);

                visited.add(curCell);

            }

            // Movemos las celdas que deben estar a la derecha de la columna nueva

            for (Cell curCell : nextColumnsCells) {

                if(visited.contains(curCell)){

                    continue;

                }

                curCell.setX(curCell.getX() + columnWidth);

                visited.add(curCell);

            }

            // Ampliamos la anchura de las celdas que son atravesadas por la l?nea vertical de donde se ha a?adido la columna nueva

            for (Cell curCell : columnTraversedCells) {

                if(visited.contains(curCell)){

                    continue;

                }

                curCell.setWidth(curCell.getWidth()+columnWidth);

            }

            /*Recalculamos la dimension segun la columna a?adida*/

            this.dimension.setSize(dimension.getWidth()+columnWidth, dimension.getHeight());

            /*Devolvemos la dimension que ten?a el cajet?n de manera proporcionada*/

            resize(oldDimension);

        } catch (Exception ex) {

            LOGGER.warn("Can't insert column after cell "+Objects.toString(cell), ex);

        }

    }

    /**

     * Devuelve las celdas que empiezan en la l?nea horizontal en que est? a una altura y

     *

     * @param y

     * @return

     */

    private List<Cell> getRowCells(double y) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(MathUtils.equals(cell.getY(),y,MAPBOX_EPSILON)) { //FIXME: entorno

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que empiezan en la l?nea horizontal en que est? a una altura y

     *

     * @param y

     * @return

     */

    private List<Cell> getRowCellsBetween(double y, double y1) {

        Set<Cell> res = new HashSet();

        for (Cell cell : cells) {

            if (MathUtils.equals(cell.getY(), y, MAPBOX_EPSILON)

                && MathUtils.equals(cell.getY() + cell.getHeight(), y1, MAPBOX_EPSILON)) {

                res.add(cell);

            }

            if (MathUtils.equals(cell.getY(), y, MAPBOX_EPSILON)

                && cell.getY() + cell.getHeight() < y1) {

                res.add(cell);

            }

            if (MathUtils.equals(cell.getY() + cell.getHeight(), y1, MAPBOX_EPSILON)

                && cell.getY() > y) {

                res.add(cell);

            }

            if(cell.getY() > y && cell.getY()+cell.getHeight() < y1) {

                res.add(cell);

            }

        }

        return new ArrayList<>(res);

    }

    /**

     * Devuelve las celdas que empiezan debajo de la l?nea horizontal en que est? a una altura y

     *

     * @param y

     * @return

     */

    private List<Cell> getNextRowsCells(double y) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(cell.getY() >= y || MathUtils.equals(cell.getY(),y,MAPBOX_EPSILON)) {

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que terminan en la l?nea horizontal que est? a una altura y

     *

     * @param y

     * @return

     */

    private List<Cell> getPreviousRowCells(double y) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(MathUtils.equals(cell.getY()+cell.getHeight(),y,MAPBOX_EPSILON)) {

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que son atravesadas por la l?nea horizontal que est? a una altura y

     *

     * @param y

     * @return

     */

    private List<Cell> getTraversedRowCells(double y) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(cell.getY() < y && cell.getY()+cell.getHeight() > y) {

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que empiezan en la l?nea vertical que est? a una distancia x del origen

     *

     * @param y

     * @return

     */

    private List<Cell> getColumnCells(double x) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(MathUtils.equals(cell.getX(),x,MAPBOX_EPSILON)) {

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que empiezan en la l?nea horizontal en que est? a una altura y

     *

     * @param x

     * @return

     */

    private List<Cell> getColumnCellsBetween(double x, double x1) {

        Set<Cell> res = new HashSet();

        for (Cell cell : cells) {

            if(MathUtils.equals(cell.getX(),x,MAPBOX_EPSILON) &&

                MathUtils.equals(cell.getX()+cell.getWidth(),x1,MAPBOX_EPSILON)) {

                res.add(cell);

            }

            if(MathUtils.equals(cell.getX(),x,MAPBOX_EPSILON) &&

                cell.getX()+cell.getWidth()< x1) {

                res.add(cell);

            }

            if(MathUtils.equals(cell.getX()+cell.getWidth(),x1,MAPBOX_EPSILON)&&

                cell.getX() > x) {

                res.add(cell);

            }

            if(cell.getX() > x && cell.getX()+cell.getWidth() < x1) {

                res.add(cell);

            }

        }

        return new ArrayList<>(res);

    }

    /**

     * Devuelve las celdas que empiezan m?s all? de la l?nea vertical que est? a una distancia x del origen

     *

     * @param y

     * @return

     */

    private List<Cell> getNextColumnsCells(double x) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(cell.getX() >= x || MathUtils.equals(cell.getX(),x,MAPBOX_EPSILON)) {

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que terminan en la l?nea vertical que est? a una distancia x del origen

     *

     * @param y

     * @return

     */

    private List<Cell> getPreviousColumnCells(double x) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(MathUtils.equals(cell.getX()+cell.getWidth(),x,MAPBOX_EPSILON)) {

                res.add(cell);

            }

        }

        return res;

    }

    /**

     * Devuelve las celdas que son atravesadas por la l?nea vertical que est? a una distancia x del origen

     *

     * @param y

     * @return

     */

    private List<Cell> getTraversedColumnCells(double x) {

        List<Cell> res = new ArrayList<>();

        for (Cell cell : cells) {

            if(cell.getX() < x && cell.getX()+cell.getWidth() > x) {

                res.add(cell);

            }

        }

        return res;

    }

    public void dump(List<Cell> theCells) {

        if(theCells == null){

            theCells = cells;

        }

        for (Cell cell : theCells) {

            System.out.println(cell.toString());

        }

    }

    public void sort() {

        Collections.sort(cells, (Cell o1, Cell o2) -> {

            int res = Double.compare(o1.getY(), o2.getY());

            if(res == 0){

                res = Double.compare(o1.getX(), o2.getX());

            }

            return res;

        });

    }

    public Cell join(List<Cell> theCells) {

        Cell join = (Cell) CloneableUtils.cloneQuietly(theCells.get(0));

        for (Cell theCell : theCells) {

            join.join(theCell);

        }

        return join;

    }

    public void combine(List<Cell> theCells) {

        Cell join = join(theCells);

        if(join == null) {

            return;

        }

        removeCells(theCells);

        cells.add(join);

    }

    public void splitCellHorizontally(Cell theCell) {

        double h = theCell.getHeight() / 2;

        theCell.setHeight(h);

        Cell cloned = (Cell) CloneableUtils.cloneQuietly(theCell);

        cloned.setY(theCell.getY() + h);

        cells.add(cloned);

    }

    public void splitCellsHorizontally(List<Cell> theCells) {

        for (Cell theCell : theCells) {

            splitCellHorizontally(theCell);

        }

    }

    public void splitCellVertically(Cell theCell) {

        double w = theCell.getWidth() / 2;

        theCell.setWidth(w);

        Cell cloned = (Cell) CloneableUtils.cloneQuietly(theCell);

        cloned.setX(theCell.getX() + w);

        cells.add(cloned);

    }

    public void splitCellsVertically(List<Cell> theCells) {

        for (Cell theCell : theCells) {

            splitCellVertically(theCell);

        }

    }

    public void removeCells(List<Cell> theCells) {

        cells.removeAll(theCells);

    }

    public void removeCells(Rectangle r) {

        for (Iterator<Cell> iterator = cells.iterator(); iterator.hasNext();) {

            Cell cell = iterator.next();

            if(cell.isContained(r)) { // || cell.intersects(r)){

                iterator.remove();

            }

        }

    }

    public void removeColumn(Cell cell) {

        /* Nos guardamos la dimension del cajetin actual para devolversela al acabar */

        Dimension2D oldDimension = (Dimension2D)(this.dimension.clone());

        double x = cell.getX();

        double columnWidth = cell.getWidth();

        List<Cell> columnCells = getColumnCellsBetween(x, x+columnWidth);

        List<Cell> nextColumnsCells = getNextColumnsCells(cell.getX()+cell.getWidth());

        List<Cell> leftTraversedColumnsCells = getTraversedColumnCells(cell.getX());

        List<Cell> rightTraversedColumnsCells = getTraversedColumnCells(cell.getX()+cell.getWidth());

        List<Cell> visited = new ArrayList<>();

        for (Cell columnCell : columnCells) {

            cells.remove(columnCell);

            visited.add(columnCell);

        }

        for (Cell nextColumnsCell : nextColumnsCells) {

            if(visited.contains(nextColumnsCell)){

                continue;

            }

            nextColumnsCell.setX(nextColumnsCell.getX()-columnWidth);

            visited.add(nextColumnsCell);

        }

        for (Cell leftTraversedColumnsCell : leftTraversedColumnsCells) {

            if(visited.contains(leftTraversedColumnsCell)){

                continue;

            }

            if(rightTraversedColumnsCells.contains(leftTraversedColumnsCell)){

                leftTraversedColumnsCell.setWidth(leftTraversedColumnsCell.getWidth()-columnWidth);

            } else {

                leftTraversedColumnsCell.setWidth(x-leftTraversedColumnsCell.getX());

            }

            visited.add(leftTraversedColumnsCell);

        }

        for (Cell rightTraversedColumnsCell : rightTraversedColumnsCells) {

            if(visited.contains(rightTraversedColumnsCell)){

                continue;

            }

            rightTraversedColumnsCell.setWidth(rightTraversedColumnsCell.getX()+rightTraversedColumnsCell.getWidth()-(x+columnWidth));

            rightTraversedColumnsCell.setY(x+columnWidth);

        }

        /*Recalculamos la dimension segun la columna a?adida*/

        this.dimension.setSize(dimension.getWidth()-columnWidth, dimension.getHeight());

        /*Devolvemos la dimension que ten?a el cajet?n de manera proporcionada*/

        resize(oldDimension);

    }

    public void removeRow(Cell cell) {

        /* Nos guardamos la dimension del cajetin actual para devolversela al acabar */

        Dimension2D oldDimension = (Dimension2D)(this.dimension.clone());

        double y = cell.getY();

        double rowHeight = cell.getHeight();

        List<Cell> rowCells = getRowCellsBetween(y, y+rowHeight);

        List<Cell> nextRowsCells = getNextRowsCells(cell.getY()+cell.getHeight());

        List<Cell> upTraversedRowsCells = getTraversedRowCells(cell.getY());

        List<Cell> downTraversedRowsCells = getTraversedRowCells(cell.getY()+cell.getHeight());

        List<Cell> visited = new ArrayList<>();

        for (Cell rowCell : rowCells) {

                cells.remove(rowCell);

                visited.add(rowCell);

        }

        for (Cell nextRowsCell : nextRowsCells) {

            if(visited.contains(nextRowsCell)){

                continue;

            }

            nextRowsCell.setY(nextRowsCell.getY()-rowHeight);

            visited.add(nextRowsCell);

        }

        for (Cell upTraversedRowsCell : upTraversedRowsCells) {

            if(visited.contains(upTraversedRowsCell)){

                continue;

            }

            if(downTraversedRowsCells.contains(upTraversedRowsCell)){

                upTraversedRowsCell.setHeight(upTraversedRowsCell.getHeight()-rowHeight);

            } else {

                upTraversedRowsCell.setHeight(y-upTraversedRowsCell.getY());

            }

            visited.add(upTraversedRowsCell);

        }

        for (Cell downTraversedRowsCell : downTraversedRowsCells) {

            if(visited.contains(downTraversedRowsCell)){

                continue;

            }

            downTraversedRowsCell.setHeight(downTraversedRowsCell.getY()+downTraversedRowsCell.getHeight()-(y+rowHeight));

            downTraversedRowsCell.setY(y+rowHeight);

        }

        /*Recalculamos la dimension segun la fila borrada*/

        this.dimension.setSize(dimension.getWidth(), dimension.getHeight() - rowHeight);

        /*Devolvemos la dimension que ten?a el cajet?n de manera proporcionada*/

        resize(oldDimension);

    }

    public void resize(Dimension2D dimension){

        if (this.dimension != null) {

            double scaleX = dimension.getWidth() / this.dimension.getWidth();

            double scaleY = dimension.getHeight() / this.dimension.getHeight();

            for (Cell cell : cells) {

                cell.setWidth(cell.getWidth() * scaleX);

                cell.setHeight(cell.getHeight() * scaleY);

                cell.setX(cell.getX() * scaleX);

                cell.setY(cell.getY() * scaleY);

            }

        }

        this.dimension = dimension;

    }

    @Override

    public boolean isEmpty() {

        return this.cells.isEmpty();

    }

    public Pair<Integer, Cell> getRelativePosition(Point2D p, double tolerance) {

        for (Cell cell : cells) {

            if(Math.abs(cell.getX()-p.getX())<=tolerance){

                return new ImmutablePair<>(POSITION_ON_LEFT_EDGE_OF_CELL, cell);

            }

            if(Math.abs(cell.getY()-p.getY())<=tolerance){

                return new ImmutablePair<>(POSITION_AT_TOP_OF_CELL, cell);

            }

            if(Math.abs(cell.getX()+cell.getWidth()-p.getX())<=tolerance){

                return new ImmutablePair<>(POSITION_ON_RIGHT_EDGE_OF_CELL, cell);

            }

            if(Math.abs(cell.getY()+cell.getHeight()-p.getY())<=tolerance){

                return new ImmutablePair<>(POSITION_AT_BOTOM_OF_CELL, cell);

            }

            if(cell.getRectangle().contains(p)){

                return new ImmutablePair<>(POSITION_IN_CELL, cell);

            }

        }

        return new ImmutablePair<>(POSITION_OUT_OF_MAPBOX, null);

    }

    public void moveVerticalLine(double x0, double x1){

        List<Cell> columnCells = getColumnCells(x0);

        double maxX = Double.POSITIVE_INFINITY;

        for (Cell columnCell : columnCells) {

            maxX = Math.min(columnCell.getX()+columnCell.getWidth(), maxX);

        }

        List<Cell> previousColumnCells = getPreviousColumnCells(x0);

        double minX = Double.NEGATIVE_INFINITY;

        for (Cell previousColumnCell : previousColumnCells) {

            minX = Math.max(previousColumnCell.getX(), minX);

        }

        if(x1 < minX){

            throw new IllegalArgumentException("The line cannot be moved beyond the previous cell");

        }

        if(x1 > maxX){

            throw new IllegalArgumentException("The line cannot be moved beyond the next cell");

        }

        if(MathUtils.equals(x0, 0d, MAPBOX_EPSILON)) { //Primera l?nea afecta a la dimensi?n del cajet?n

            for (Cell cell : cells) {

                if(cell.getX() == 0d){

                    cell.setWidth(cell.getWidth()-x1);

                } else {

                    cell.setX(cell.getX()-x1);

                }

            }

            this.dimension.setSize(this.dimension.getWidth()-(x1-x0), this.dimension.getHeight());

        } else if(MathUtils.equals(x0,dimension.getWidth(),MAPBOX_EPSILON)) { //Ultima l?nea afecta a la dimensi?n del cajet?n

            for (Cell previousColumnCell : previousColumnCells) {

                previousColumnCell.setWidth(x1-previousColumnCell.getX());

            }

            this.dimension.setSize(this.dimension.getWidth()+(x1-x0), this.dimension.getHeight());

        } else { //No afecta a la dimensi?n del cajet?n

            for (Cell previousColumnCell : previousColumnCells) {

                previousColumnCell.setWidth(x1-previousColumnCell.getX());

            }

            for (Cell columnCell : columnCells) {

                columnCell.setX(x1);

                columnCell.setWidth(columnCell.getWidth()-(x1-x0));

            }

        }

    }

    public void moveHorizontalLine(double y0, double y1){

        List<Cell> rowCells = getRowCells(y0);

        double maxY = Double.POSITIVE_INFINITY;

        for (Cell rowCell : rowCells) {

            maxY = Math.min(rowCell.getY()+rowCell.getHeight(), maxY);

        }

        List<Cell> previousRowCells = getPreviousRowCells(y0);

        double minY = Double.NEGATIVE_INFINITY;

        for (Cell previousRowCell : previousRowCells) {

            minY = Math.max(previousRowCell.getY(), minY);

        }

        if(y1 < minY){

            throw new IllegalArgumentException("The line cannot be moved beyond the previous cell");

        }

        if(y1 > maxY){

            throw new IllegalArgumentException("The line cannot be moved beyond the next cell");

        }

        if(MathUtils.equals(y0,0d,MAPBOX_EPSILON)) { //Primera l?nea afecta a la dimensi?n del cajet?n

            for (Cell cell : cells) {

                if(cell.getY() == 0d){

                    cell.setHeight(cell.getHeight()-y1);

                } else {

                    cell.setY(cell.getY()-y1);

                }

            }

            this.dimension.setSize(this.dimension.getWidth(), this.dimension.getHeight()-(y1-y0));

        } else if(MathUtils.equals(y0,dimension.getHeight(),MAPBOX_EPSILON)) { //Ultima l?nea afecta a la dimensi?n del cajet?n

            for (Cell previousRowCell : previousRowCells) {

                previousRowCell.setHeight(y1-previousRowCell.getY());

            }

            this.dimension.setSize(this.dimension.getWidth(), this.dimension.getHeight()+(y1-y0));

        } else { //No afecta a la dimensi?n del cajet?n

            for (Cell previousRowCell : previousRowCells) {

                previousRowCell.setHeight(y1-previousRowCell.getY());

            }

            for (Cell rowCell : rowCells) {

                rowCell.setY(y1);

                rowCell.setHeight(rowCell.getHeight()-(y1-y0));

            }

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        MapBoxModel other = (MapBoxModel) super.clone();

        List<Cell> clonedCells = new ArrayList<>();

        for (Cell cell : cells) {

            clonedCells.add(cell.clone());

        }

        other.cells = clonedCells;

        if(this.dimension != null){

            other.dimension = (Dimension2D) this.dimension.clone();

        }

        return other;

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(MapBoxModel.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameMapBox persistence definition", null, null);

            definition.addDynFieldList("cells").setClassOfItems(Cell.class).setMandatory(true);

            definition.addDynFieldDouble("width").setMandatory(true);

            definition.addDynFieldDouble("height").setMandatory(true);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        List<Cell> c = state.getList("cells");

        if(c!=null){

            this.cells = new ArrayList<>(c);

        }

        double width = state.getDouble("width");

        double height = state.getDouble("height");

        this.dimension = new Dimension2DDouble(width, height);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("cells", this.cells);

        state.set("width", this.dimension.getWidth());

        state.set("height", this.dimension.getHeight());

    }

}