Application: gvSIG desktop » gvSIG Document Layout

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

import java.awt.Color;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import javax.json.JsonObject;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

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.fmap.mapcontext.layers.vectorial.GraphicLayer;

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.symbology.SymbologyLocator;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.text.ISimpleTextSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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.task.JTaskStatus;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

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

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

import org.gvsig.tools.task.SimpleTaskStatus;

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 FeatureStore store;

    private FeatureQuery query;

    private FeatureSet selection;

    private Feature current_row;

    private MutableSymbolTable symbolTable;

    private FeatureSymbolTable fSymbolTable;

    private Iterable<Feature> set;

    private int featuresCount;

    private LayoutReportActionParameters parameters;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    private LayoutReportActionImpl(ReportActionFactory factory, FeatureStore store, JsonObject json) {

        super(factory, null);

        this.store = store;

        this.selection = null;

        this.query = null;

        this.current_row = null;

        this.parameters = LayoutReportActionParameters.create();

        this.parameters.fromJson(json);

        this.setReportName(this.parameters.getIdentifier());

        this.setReportLabel(this.parameters.getLabel());

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

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

        // Fake layoutReportAction constructor

        this(

                factory,

                store,

                LayoutReportActionParameters.create(store.getName()).toJson()

        );

        try {

            this.selection = store.createFeatureSelection();

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

        } catch(Throwable t) {

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

        }

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

        this.current_row = feature;

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

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

        this(factory, store, json);

        this.selection = selection;

        this.query = query;

    }

    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;

                    DisposeUtils.bind(this.set);

                }

            }

        }

        return this.set;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        if (!this.isEnabled()) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        final WindowManager_v2 windowManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        final JTaskStatus taskStatusPanel = ToolsSwingLocator.getTaskStatusSwingManager().createJTaskStatus();

        final LayoutReportAction report = this;

        SimpleTaskStatus theStatus = this.getStatus();

        theStatus.setIndeterminate();

        taskStatusPanel.setShowRemoveTaskButton(false);

        taskStatusPanel.bind(theStatus);

        ToolsSwingUtils.ensureRowsCols(taskStatusPanel, 4, 100, 5, 200);

        windowManager.showWindow(

                taskStatusPanel.asJComponent(),

                i18n.getTranslation("_Creating_report")+" '" + this.getReportLabel() + "'...",

                WindowManager.MODE.TOOL

        );

        Thread task = new Thread(() -> {

            List<File> singlePdfFiles = new ArrayList();

            Iterable<Feature> features = null;

            try {

                String title = this.getReportLabel();

                String creator = "gvSIG-desktop";

                String subject = "Layout report";

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

                        int pag = 0;

                        features = features();

                        theStatus.setRangeOfValues(1, featuresCount);

                        theStatus.message(i18n.getTranslation("_Building_pages"));

                        for (Feature feature : features) {

                            if( theStatus.isCancellationRequested() ) {

                                theStatus.cancel();

                                return;

                            }

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

                            singlePdfFiles.add(f);

                            theStatus.incrementCurrentValue();

                        }

                        theStatus.message(i18n.getTranslation("_Building_pdf"));

                        PDFManager pdfManager = PDFLocator.getPDFManager();

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

                        if (this.parameters.isUseInternalPdfViewer()) {

                            this.showEmbedded(pdfFile);

                        } else {

                            this.showExternal(pdfFile);

                        }

                        theStatus.terminate();

                        SwingUtilities.invokeLater(() -> {

                            taskStatusPanel.setVisible(false);

                        });

            } catch (Throwable t) {

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

                theStatus.abort();

            } finally {

                for (File singlePdfFile : singlePdfFiles) {

                    singlePdfFile.delete();

                }

                DisposeUtils.disposeQuietly(features);

            }

        }, "Report_" + report.getReportName());

        task.start();

    }

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

        this.current_row = feature;

        final LayoutPanel layout = this.getTemplateAsLayout();

        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");

        I18nManager i18n = ToolsLocator.getI18nManager();

        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.parameters.getViewTag(), frameTag)

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

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

                        break;

                    }

                }

            }

            if (mapContext == null) {

                mapContext = mapContextCandidate;

            };

            if (mapContext != null) {

                mapContext.setPrintGraphicsLayer(this.parameters.isHighlightRecord());

                ICoordTrans ct = null;

                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())) {

                                ct = ((FLyrVect) layer).getCoordTrans();

                                break;

                            }

                        }

                    }

                }

                Geometry geom = this.current_row.getDefaultGeometry();

                if (geom != null) {

                    geom = geom.cloneGeometry();

                    if (ct != null && ct.getPOrig().equals(geom.getProjection())) {

                        geom.reProject(ct);

                    } else if (!geom.getProjection().equals(mapContext.getProjection())) {

                        ct = geom.getProjection().getCT(mapContext.getProjection());

                        geom.reProject(ct);

                    }

                    if (this.parameters.isZoomToCurrentRow()) {

                        Envelope envelope = geom

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

                        mapContext.getViewPort().setEnvelope(envelope);

                    } else if (this.parameters.isCenterToCurrentRow()) {

                        Envelope envelope = geom

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

                        center(mapContext, envelope);

                    } else {

                        //DO NOTHING ??

                    }

                    if(this.parameters.isHighlightRecord()){

                        GraphicLayer graphicsLayer = mapContext.getGraphicsLayer();

                        graphicsLayer.clear();

                        int idSymbol = graphicsLayer.addSymbol(this.parameters.getHighlightSymbol(this.store));

                        if(this.parameters.isApplySymbolToRecord()){

                            //Do nothing, is the default behavior

                        }

                        if(this.parameters.isApplySymbolToEverythingExceptRecord()){

                            Geometry viewPortGeom = mapContext.getViewPort().getAdjustedEnvelope().getGeometry();

                            if(geom.isValid()) {

                                geom = viewPortGeom.difference(geom);

                            } else {

                                Geometry geom2 = geom.fix();

                                if(geom2 != null){

                                    geom = viewPortGeom.difference(geom2);

                                } else {

                                    geom = viewPortGeom;

                                    ISimpleTextSymbol textSymbol = SymbologyLocator.getSymbologyManager().createSimpleTextSymbol();

                                    textSymbol.setTextColor(Color.RED.darker());

                                    textSymbol.setHaloColor(Color.WHITE);

                                    textSymbol.setDrawWithHalo(true);

                                    int idPointSymbol = graphicsLayer.addSymbol(textSymbol);

                                    graphicsLayer.addGraphic("LayourReport", geom.centroid(), idPointSymbol, i18n.getTranslation("_Invalid_geometry"));

                                }

                            }

                        }

                        graphicsLayer.addGraphic("LayourReport", geom, idSymbol);

                    }

                }

            }

            context.fullRefresh();

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

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

            layout.layoutToPDF(pdfFile);

        } catch (Throwable th) {

            LOGGER.warn("Can't print report.", th);

            this.getStatus().message(i18n.getTranslation("_Cant_print_report")+"\n\n"+th.getMessage());

            throw th;

        } 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) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(() -> {

                showEmbedded(pdfFile);

            });

            return;

        }

        try {

            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

            );

        } catch (Exception ex) {

            LOGGER.warn("Can't show pdf file '" + Objects.toString(pdfFile) + "'", ex);

            I18nManager i18n = ToolsLocator.getI18nManager();

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_show_pdf_file")+" (" + Objects.toString(pdfFile) + ")\n\n"+BaseException.getMessageStack(ex, 0),

                    "Creating report '" + this.getReportLabel() + "'",

                    JOptionPane.WARNING_MESSAGE

            );

        }

    }

    private void showExternal(File pdfFile) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(() -> {

                showExternal(pdfFile);

            });

            return;

        }

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

        desktop.open(pdfFile);

    }

    private LayoutPanel getTemplateAsLayout() throws Exception {

        ResourcesStorage.Resource resource = getTemplateAsResource();

        if(resource == null){

            return null;

        }

        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);

        }

    }

    @Override

    public ResourcesStorage.Resource getTemplateAsResource() {

        ResourcesStorage resources = store.getResourcesStorage();

        if (resources == null) {

            return null;

        }

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

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

        return resource;

    }

    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;

    }

    public LayoutReportActionParameters getParameters() {

        return this.parameters;

    }

}