Application: gvSIG desktop » gvSIG Document Layout

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

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import javax.json.Json;

import javax.json.JsonObject;

import javax.swing.JComponent;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

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

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

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

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

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

import static org.gvsig.app.project.documents.layout.report.LayoutReportActionFactory.LAYOUT_REPORT_ACTION_NAME;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.desktopopen.DesktopOpen;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

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

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.report.AbstractReportAction;

import org.gvsig.fmap.dal.swing.report.ReportActionFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

import org.gvsig.pdf.lib.api.PDFDocument;

import org.gvsig.pdf.lib.api.PDFLocator;

import org.gvsig.pdf.lib.api.PDFManager;

import org.gvsig.pdf.swing.api.PDFSwingLocator;

import org.gvsig.pdf.swing.api.PDFSwingManager;

import org.gvsig.pdf.swing.api.PDFViewer;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingUtils;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class LayoutReportActionImpl extends AbstractReportAction implements LayoutReportAction {

    public static LayoutReportActionImpl createFakeLayoutReportAction(Document doc) {

        ApplicationManager application = ApplicationLocator.getApplicationManager();

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        Feature f = null;

        FeatureStore theStore = null;

        ReportActionFactory theFactory = dataSwingManager.getReportActionFactory(LAYOUT_REPORT_ACTION_NAME);

        try {

            IWindow activeView = application.getActiveWindow(ViewDocument.class);

            ViewDocument viewdoc = (ViewDocument) ((IView)activeView).getDocument();

            FLyrVect layer = viewdoc.getMapContext().getLayers().getFirstActiveVectorLayer();

            theStore = layer.getFeatureStore();

            if( theStore.isFeatureSelectionEmpty() ) {

                f = theStore.first();

            } else {

                f = theStore.getFeatureSelection().first();

            }

        } catch(Throwable t) {

            LOGGER.debug("Can't retrieve test feature",t);

        }

        LayoutReportActionImpl report = new LayoutReportActionImpl(theFactory, theStore, f);

        report.getSymbolTable().setVar("$LAYOUT", doc);

        report.getSymbolTable().setVar("$PAGE", 1);

        report.getSymbolTable().setVar("$PAGES", 1);

        return report;        

    }

    private final JsonObject json;

    private final FeatureStore store;

    private final FeatureQuery query;

    private FeatureSet selection;

    private Feature current_row;

    private MutableSymbolTable symbolTable;

    FeatureSymbolTable fSymbolTable;

    private boolean centerToCurrentRow;

    private boolean zoomToCurrentRow;

    private int bufferSize;

    private boolean selectCurrentRow;

    private boolean useInternalPdfViewer;

//    private FeatureSet set;

    private Iterable<Feature> set;

    private int featuresCount;

    private String viewTag;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    private LayoutReportActionImpl(ReportActionFactory factory, FeatureStore store, Feature feature) {

        // Fake layoutReportAction constructor

        super(factory, null);

        try {

            this.selection = store.createFeatureSelection();

            ((FeatureSelection)this.selection).select(feature);

        } catch(Throwable t) {

            LOGGER.debug("Can't initialize selection",t);

        }

        this.store = store;

        this.query = store.createFeatureQuery(feature.createFilter());

        this.current_row = feature;

        this.json = Json.createObjectBuilder()

                .add(LAYOUT_REPORT_NAME, store.getName())

                .add(LAYOUT_REPORT_TYPE, LAYOUT_REPORT_ACTION_NAME)

                .add(LAYOUT_REPORT_LABEL, store.getName())

                .build();

        this.setReportName(this.json.getString(LAYOUT_REPORT_NAME, store.getName()));

        this.setReportLabel(this.json.getString(LAYOUT_REPORT_LABEL, this.getReportName()));

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public LayoutReportActionImpl(ReportActionFactory factory, FeatureStore store, FeatureQuery query, FeatureSet selection, final JsonObject json) {

        super(factory, null);

        this.json = json;

        this.setReportName(this.json.getString(LAYOUT_REPORT_NAME, store.getName()));

        this.setReportLabel(this.json.getString(LAYOUT_REPORT_LABEL, this.getReportName()));

        this.setCenterToCurrentRow(this.json.getBoolean(LAYOUT_REPORT_CENTER_TO_CURRENT_ROW, true));

        this.setZoomToCurrentRow(this.json.getBoolean(LAYOUT_REPORT_ZOOM_TO_CURRENT_ROW, true));

        this.setBufferSize(this.json.getInt(LAYOUT_REPORT_BUFFER_SIZE, 0));

        this.setSelectCurrentRow(this.json.getBoolean(LAYOUT_REPORT_SELECT_CURRENT_ROW, false));

        this.setViewTag(this.json.getString(LAYOUT_REPORT_VIEW_TAG, null));

        this.setUseInternalPdfViewer(this.json.getBoolean(LAYOUT_REPORT_USE_INTERNAL_PDF_VIEWER, true));

        this.selection = selection;

        this.store = store;

        this.query = query;

        this.current_row = null;

    }

    public Feature row() {

        return this.current_row;

    }

    private Iterable<Feature> features() {

        if( this.set == null ) {

                if(this.selection == null){

                try {

                    FeatureSet fset = store.getFeatureSet(query);

                    this.featuresCount = fset.size();

                    this.set = fset;

                } catch (DataException ex) {

                    throw new RuntimeException("Can't create dynamic-text report.", ex);

                }

            } else {

                this.featuresCount = this.selection.size();

                if(this.selection instanceof FeatureSelection){

                    this.set = this.store.getFeaturesIterable(((FeatureSelection)this.selection).referenceIterator());

                } else {

                    this.set = this.selection;

                }

            }

        }

        return this.set;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        try {

            String title = this.getReportLabel();

            String creator = "gvSIG-desktop";

            String subject = "Layout report";

            File pdfFile = ToolsLocator.getFoldersManager().getUniqueTemporaryFile("report.pdf");

            List<File> singlePdfFiles = new ArrayList();

            int pag = 0;

            for (Feature feature : features()) {

                File f = printReport(feature,++pag);

                singlePdfFiles.add(f);

            }

            PDFManager pdfManager = PDFLocator.getPDFManager();

            pdfManager.merge(singlePdfFiles, pdfFile, title, creator, subject);

            for (File singlePdfFile : singlePdfFiles) {

                singlePdfFile.delete();

            }

            if (this.isUseInternalPdfViewer()) {

                this.showEmbedded(pdfFile);

            } else {

                this.showExternal(pdfFile);

            }

            this.getStatus().terminate();

        } catch (Throwable t) {

            LOGGER.warn("Can't create layout report.", t);

            this.getStatus().abort();

        }

    }

    private File printReport(Feature feature, int page) throws Exception {

        this.current_row = feature;

        final LayoutPanel layout = this.loadTemplate();

        final LayoutContext context = layout.getLayoutContext();

        final Document document = layout.getDocument();

        this.getSymbolTable();

        fSymbolTable.setFeature(current_row);

        this.symbolTable.setVar("$LAYOUT", document);

        this.symbolTable.setVar("$PAGE", page);

        this.symbolTable.setVar("$PAGES", this.featuresCount);

        File pdfFile = null;

        Object previous_report = document.getProperty("$REPORT");

        try {

            document.setProperty("$REPORT", this);

            /*

                TODO: Aqui podriamos consultar en el json para ver si hacemos:

                x zoom al envelope de la geometria de current_row, 

                x si le aplicamos un buffer antes a ese envelop, 

                X si la seleccionamos... 

                - asi como con que vista tenemos que hacerlo. ????

             */

            int count = 1;

            MapContext mapContext = null;

            MapContext mapContextCandidate = null;

            for (IFFrame frame : context.getAllFFrames()) {

                if (frame instanceof FFrameView) {

                    if(mapContextCandidate == null){

                        mapContextCandidate = ((FFrameView) frame).getMapContext();

                    }

                    String frameTag = frame.getTag();

                    String countTag = "#"+count;

                    if(StringUtils.equalsIgnoreCase(this.getViewTag(), frameTag) ||

                       StringUtils.equalsIgnoreCase(this.getViewTag(), countTag)){

                        mapContext = ((FFrameView) frame).getMapContext();

                        break;

                    }

                }

            }

            if(mapContext == null){

                mapContext = mapContextCandidate;

            };

            FeatureStore storeInLayout = this.store;

            if (mapContext != null) {

                Envelope envelope = mapContext.getViewPort().getEnvelope();

                if (isZoomToCurrentRow()) {

                    envelope = this.current_row.getDefaultGeometry()

                            .getEnvelope().getGeometry().buffer(getBufferSize()).getEnvelope();

                    mapContext.getViewPort().setEnvelope(envelope);

                } else if (isCenterToCurrentRow()) {

                    envelope = this.current_row.getDefaultGeometry()

                            .getEnvelope().getGeometry().buffer(getBufferSize()).getEnvelope();

                    center(mapContext, envelope);

                } else {

                    //DO NOTHING ??

                }

                /*

                    FIXME: Habria que localizar el store en la vista y buscar ahi

                    la current_row para seleccionarla. Seleccionando directamente

                    la del store puede no funcionar por no ser el mismo store.

                 */

                for (FLayer layer : mapContext.getLayers().getLayers(null)) {

                    if (layer instanceof FLyrVect) {

                        FeatureStore layerStore = ((FLyrVect) layer).getFeatureStore();

                        if (layerStore != null) {

                            if (layerStore.getParameters().isTheSameStore(this.store.getParameters())) {

                                storeInLayout = layerStore;

                            }

                        }

                    }

                }

            }

            storeInLayout.getFeatureSelection().deselectAll();

            if (isSelectCurrentRow()) {

                storeInLayout.getFeatureSelection().select(current_row.getReference());

            }

            context.fullRefresh();

            layout.getLayoutControl().getLayoutDraw().initialize();

            pdfFile = ToolsLocator.getFoldersManager().getUniqueTemporaryFile("report.pdf");

            layout.layoutToPDF(pdfFile);

        } finally {

            document.setProperty("$REPORT", previous_report);

        }

        return pdfFile;

    }

    private void center(MapContext mapContext, Envelope envelope) throws LocatorException, CreateEnvelopeException {

        ViewPort viewPort = mapContext.getViewPort();

        Envelope oldExtent = viewPort.getAdjustedEnvelope();

        double oldCenterX = oldExtent.getCenter(0);

        double oldCenterY = oldExtent.getCenter(1);

        double centerX = envelope.getCenter(0);

        double centerY = envelope.getCenter(1);

        Point2D.Double center = new Point2D.Double(centerX, centerY);

        double movX = centerX - oldCenterX;

        double movY = centerY - oldCenterY;

        double minx = oldExtent.getMinimum(0) + movX;

        double miny = oldExtent.getMinimum(1) + movY;

        double maxX = oldExtent.getMaximum(0) + movX;

        double maxY = oldExtent.getMaximum(1) + movY;

        Envelope extent = GeometryLocator.getGeometryManager().createEnvelope(

                minx, miny,

                maxX, maxY,

                Geometry.SUBTYPES.GEOM2D);

        viewPort.setEnvelope(extent);

    }

    private void showEmbedded(File pdfFile) throws IOException {

        final WindowManager windowManager = ToolsSwingLocator.getWindowManager();

        final PDFSwingManager pdfSwingManager = PDFSwingLocator.getPDFSwingManager();

        final PDFManager pdfManager = PDFLocator.getPDFManager();

        final PDFDocument pdfdoc = pdfManager.createPDFDocument(pdfFile);            

        PDFViewer viewer = pdfSwingManager.createPDFViewer();

        viewer.put(pdfdoc);

        viewer.setMode(PDFViewer.MODE_LIGHT);

        JComponent comp = viewer.asJComponent();

        Dimension size = ToolsSwingUtils.ensureRowsCols(comp.getPreferredSize(), 20, 100, 40, 150);

        comp.setSize(size);

        String title = "Report: " + this.getLabel();

        windowManager.showWindow(

                comp,

                title,

                WindowManager.MODE.WINDOW

        );

    }

    private void showExternal(File pdfFile) {

        DesktopOpen desktop = ToolsUtilLocator.getToolsUtilManager().createDesktopOpen();

        desktop.open(pdfFile);

    }

    private LayoutPanel loadTemplate() throws Exception {

        ResourcesStorage resources = store.getResourcesStorage();

        if (resources == null) {

            return null;

        }

        String templateName = this.json.getString(LAYOUT_REPORT_TEMPLATE_NAME, LAYOUT_REPORT_DEFAULT_TEMPLATE_NAME); // "1.layout"...

        ResourcesStorage.Resource resource = resources.getResource(templateName);

        InputStream is = null;

        try {

            is = resource.asInputStream();

            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            PersistentState persistentState = persistenceManager.loadState(is);

            LayoutPanel layout = (LayoutPanel) persistenceManager.create(persistentState);

            return layout;

        } finally {

            IOUtils.closeQuietly(is);

        }

    }

    public MutableSymbolTable getSymbolTable() {

        if( this.symbolTable == null ) {

            this.symbolTable = ExpressionUtils.createSymbolTable();

            fSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

            fSymbolTable.setFeature(current_row);

            this.symbolTable.addSymbolTable(fSymbolTable);

            this.symbolTable.setVar("$REPORT", this);

        }

        return this.symbolTable;

    }

    @Override

    public String evaluateDynamicText(String s) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        if( !manager.isDynamicText(s) ) {

            return s;

        }

        String x = manager.evaluateDynamicText(

                this.getSymbolTable(), 

                s, 

                null, 

                this.store.getResourcesStorage()

        );

        return x;

    }

    @Override

    public boolean isCenterToCurrentRow() {

        return this.centerToCurrentRow;

    }

    @Override

    public void setCenterToCurrentRow(boolean centerToCurrentRow) {

        this.centerToCurrentRow = centerToCurrentRow;

    }

    @Override

    public boolean isZoomToCurrentRow() {

        return this.zoomToCurrentRow;

    }

    @Override

    public void setZoomToCurrentRow(boolean zoomToCurrentRow) {

        this.zoomToCurrentRow = zoomToCurrentRow;

    }

    @Override

    public int getBufferSize() {

        return bufferSize;

    }

    @Override

    public void setBufferSize(int bufferSize) {

        this.bufferSize = bufferSize;

    }

    @Override

    public boolean isSelectCurrentRow() {

        return selectCurrentRow;

    }

    @Override

    public void setSelectCurrentRow(boolean selectCurrentRow) {

        this.selectCurrentRow = selectCurrentRow;

    }

    @Override

    public String getViewTag() {

        return viewTag;

    }

    @Override

    public void setViewTag(String viewTag) {

        this.viewTag = viewTag;

    }

    public  boolean isUseInternalPdfViewer() {

        return useInternalPdfViewer;

    }

    @Override

    public void setUseInternalPdfViewer(boolean useInternalPdfViewer) {

        this.useInternalPdfViewer = useInternalPdfViewer;

    }

}