Application: gvSIG desktop

package org.gvsig.fmap.mapcontext.persistence;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.impl.Envelope2D;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import org.gvsig.tools.persistence.PersistentState;

public class MapContextPersistenceTestNo extends AbstractLibraryAutoInitTestCase {

        private MapContext mc = null;

        private File tempFile = null;

        protected void doSetUp() throws Exception {

                 try {

                         System.out.println("Creating temp file for persistence...");

                        tempFile = File.createTempFile("persisted_mapcontext", ".xml");

                        if (tempFile.exists()) tempFile.delete();

                        tempFile.createNewFile();

                         System.out.println("Creating viewport...");

                        ViewPort vp = getViewPort();

                         System.out.println("Creating mapcontext...");

                        mc = new MapContext(vp);

//                        addDummyLayers(mc);

                } catch (Exception ex) {

                        System.err.println("Error while setting up mapcontext persistence test: " + ex.getMessage());

                        assertTrue(false);

                }

        }

        private ViewPort getViewPort() {

                ViewPort vp = new ViewPort(null);

                vp.setImageSize(new Dimension(640, 480));

                Envelope env = new Envelope2D(0, 0, 1000000, 1000000);

                vp.setEnvelope(env);

                env = new Envelope2D(200000, 200000, 500000, 500000);

                vp.setEnvelope(env);

                env = new Envelope2D(300000, 300000, 300000, 300000);

                vp.setEnvelope(env);

                env = new Envelope2D(400000, 400000, 200000, 200000);

                vp.setEnvelope(env);

                env = new Envelope2D(440000, 440000, 100000, 100000);

                vp.setEnvelope(env);

                env = new Envelope2D(480000, 480000, 30000, 30000);

                vp.setEnvelope(env);

                vp.setBackColor(Color.YELLOW);

                vp.setClipRect(new Rectangle2D.Double(0, 0, 10, 10));

                return vp;

        }

//        private void addDummyLayers(MapContext mcon) {

//                

//                FLayers resp = new FLayers();

//                resp.setMapContext(mcon);

//                resp.setName("root layer");

//                

//                FLayers aux = new FLayers();

//                aux.setMapContext(mcon);

//                aux.setName("Group");

//                

//                FLyrVect lyr = null;

//                IVectorLegend lgn = null;

//                FeatureStore fs = null;

//                

//                System.out.println("Adding dummy layers...");

//                        

//                fs = new DummyFileFeatureStore("1");

//                lyr = createLayer(fs);

//                lyr.setName("Layer 1");

//                try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

//                

//                aux.addLayer(lyr);

//                

//                fs = new DummyDBFeatureStore("A");

//                lyr = createLayer(fs);

//                lyr.setName("Layer A");

//                try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

//

//                aux.addLayer(lyr);

//                

//                fs = new DummyFileFeatureStore("2");

//                lyr = createLayer(fs);

//                lyr.setName("Layer 2");

//                try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

//

//                aux.addLayer(lyr);

//                

//                fs = new DummyDBFeatureStore("B");

//                lyr = createLayer(fs);

//                lyr.setName("Layer 1");

//                try { lyr.setLegend(new DummyVectorLegend(TYPES.SOLID)); } catch (LegendLayerException e) { }

//                

//                resp.addLayer(lyr);

//                resp.addLayer(aux);

//                

//                mcon.getLayers().addLayer(resp);

//        }

        private FLyrVect createLayer(FeatureStore fs) {

                FLyrVect resp = new FLyrVect();

                try {

                        resp.setDataStore(fs);

                        resp.wakeUp();

                        resp.load();

                } catch (LoadLayerException e) {

                        assertTrue("While creating dummy layer: " + e.getMessage(), false);

                }

                return resp;

        }

        public void testPersist() {

                if (true) return;

                System.out.println("Starting persistence test...");

                try {

                        FileOutputStream fos = new FileOutputStream(tempFile);

                        System.out.println("Getting mapcontext state...");

                        PersistentState pst = ToolsLocator.getPersistenceManager().getState(mc);

                        System.out.println("Saving mapcontext state...");

                        ToolsLocator.getPersistenceManager().saveState(pst, fos);

                        fos.close();

                        // ==============================================

                        // ==============================================

                        System.out.println("Mapcontext is now persisted!");

                        // ==============================================

                        System.out.println("Opening persistence file...");

                        FileInputStream fis = new FileInputStream(tempFile);

                        System.out.println("Loading mapcontext state from file...");

                        pst = ToolsLocator.getPersistenceManager().loadState(fis);

                        System.out.println("Instantiating mapcontext from state...");

                        MapContext mc2 = (MapContext) ToolsLocator.getPersistenceManager().create(pst);

                        System.out.println("Comparing original and current mapcontext...");

                        compareMapContexts(mc, mc2);

                        System.out.println("Successful mapcontext persistence test!");

                } catch (Exception ex) {

                        System.err.println("Error while testing persistence: " + ex.getMessage());

                        assertTrue(false);

                }

        }

        private void compareMapContexts(MapContext m1, MapContext m2) {

                System.out.println("Getting viewports to compare...");

                ViewPort vp1 = m1.getViewPort();

                ViewPort vp2 = m2.getViewPort();

                compareViewPorts(vp1, vp2);

                System.out.println("Getting root flayers to compare...");

                FLayers lyr1 = m1.getLayers();

                FLayers lyr2 = m2.getLayers();

                compareLayers(lyr1, lyr2);

        }

        private void compareLayers(FLayer l1, FLayer l2) {

                System.out.println("Comparing layers...");

                assertTrue("Layers of diff type!", l1.getClass().getName().compareTo(l2.getClass().getName()) == 0);

                if (l1 instanceof FLayers) {

                        System.out.println("(type FLayers)...");

                        FLayers ls1 = (FLayers) l1;

                        FLayers ls2 = (FLayers) l2;

                        assertEquals(ls1.getLayersCount(), ls2.getLayersCount());

                        int sz = ls2.getLayersCount();

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

                                compareLayers(ls1.getLayer(i), ls2.getLayer(i));

                        }

                } else {

                        if (l1 instanceof FLyrVect) {

                                System.out.println("(type FLyrVect)...");

                                FLyrVect ls1 = (FLyrVect) l1;

                                FLyrVect ls2 = (FLyrVect) l2;

                                compareVectLayers(ls1, ls2);

                        } else {

                        }

                }

        }

        private void compareVectLayers(FLyrVect l1, FLyrVect l2) {

                compareLegend(l1.getLegend(), l2.getLegend());

                compareStore(l1.getFeatureStore(), l2.getFeatureStore());

        }

        private void compareStore(FeatureStore fs1,

                        FeatureStore fs2) {

                System.out.println("Comparing stores...");

                assertTrue("Diff stores!", fs1.getName().compareTo(fs2.getName()) == 0);

        }

        private void compareLegend(ILegend l1, ILegend l2) {

                System.out.println("Comparing legends...");

                IVectorLegend vl1 = (IVectorLegend) l1;

                IVectorLegend vl2 = (IVectorLegend) l2;

                assertTrue("Diff legends!", vl1.getShapeType() == vl2.getShapeType());

        }

        private void compareViewPorts(ViewPort vp1, ViewPort vp2) {

                System.out.println("Comparing viewports...");

                assertEquals(

                                vp1.getAdjustedEnvelope().getMinimum(0),

                                vp2.getAdjustedEnvelope().getMinimum(0),

                                0.00000000000001);

                assertEquals(

                                vp1.getAdjustedEnvelope().getMinimum(1),

                                vp2.getAdjustedEnvelope().getMinimum(1),

                                0.00000000000001);

                assertEquals(

                                vp1.getAdjustedEnvelope().getMaximum(0),

                                vp2.getAdjustedEnvelope().getMaximum(0),

                                0.00000000000001);

                assertEquals(

                                vp1.getAdjustedEnvelope().getMaximum(1),

                                vp2.getAdjustedEnvelope().getMaximum(1),

                                0.00000000000001);

        }

}