Application: gvSIG desktop » gvSIG Document Layout

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.app.extension.reportfromlayout;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.nio.charset.StandardCharsets;

import java.util.List;

import java.util.function.Predicate;

import javax.json.JsonObject;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.TreeSelectionEvent;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.gui.styling.SymbolSelector;

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

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

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.report.LayoutReportAction;

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

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

import org.gvsig.app.project.documents.view.legend.gui.ISymbolSelector;

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

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

import org.gvsig.fmap.dal.swing.storesrepository.StoresRepositoryController;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

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

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

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

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

import org.gvsig.tools.swing.api.documentfilters.PositiveDoubleDocumentFilter;

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

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

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

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

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public class ConfigureReportFromLayout extends ConfigureReportFromLayoutPanelView {

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

    private StoresRepositoryController treeSourceController;

    private FeatureStore source;

    private Dialog dialog;

    private ISymbol highlightSymbol;

    public ConfigureReportFromLayout() {

        this.initComponents();

    }

    private void initComponents() {

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        translate();

        fillCboLayout();

        this.cboLayout.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doChangeLayout();

            }

        });

        this.treeSourceController = dataSwingManager.createStoresRepositoryController(this.treeSource);

        this.treeSource.addTreeSelectionListener((TreeSelectionEvent e) -> {

            doChangeSource();

            doUpdateComponents();

        });

        this.cboReport.addActionListener((ActionEvent e) -> {

            doChangeReport();

        });

        this.txtIdentifier.getDocument().addDocumentListener(new DocumentListener() {

            @Override

            public void insertUpdate(DocumentEvent e) {

                doUpdateComponents();

            }

            @Override

            public void removeUpdate(DocumentEvent e) {

                doUpdateComponents();

            }

            @Override

            public void changedUpdate(DocumentEvent e) {

               doUpdateComponents();

            }

        });

        this.chkZoomToCurrentRow.addActionListener((ActionEvent e) -> {

            doUpdateComponents();

        });

        this.btnSelectSymbol.addActionListener((ActionEvent e) -> {

            doSelectSymbol();

        });

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        PositiveDoubleDocumentFilter.install(txtBufferSize);

        Dimension screensize = ApplicationLocator.getApplicationManager().getUIManager().getInternalSize();

        ToolsSwingUtils.ensureHeightWitdh(

                this, 

                Math.max(3*(screensize.height/4), ToolsSwingUtils.rows2px(80)),

                Math.max(2*(screensize.width/4), ToolsSwingUtils.cols2px(35)), 

                7*(screensize.height/8), 

                3*(screensize.width/4)

        );        

        SwingUtilities.invokeLater(this::doUpdateComponents);

    }

    private void doChangeSource() {

        FeatureStore theSource = this.treeSourceController.getSelectedFeatureStore();

        if( theSource==null ) {

            return;

        }

        if(this.source != null){

            DisposeUtils.disposeQuietly(this.source);

        }

        this.source = theSource;

        fillCboReport();

        doUpdateComponents();

    }

    private void doChangeLayout() {

        fillCboView();

        doUpdateComponents();

    }

    private void doSelectSymbol() {

        if(this.source == null){

            return;

        }

        FeatureAttributeDescriptor geomAttr = this.source.getDefaultFeatureTypeQuietly().getDefaultGeometryAttribute();

        if(geomAttr == null){

            return;

        }

        int geomType = geomAttr.getGeomType().getType();

        if(this.highlightSymbol == null) {

            this.highlightSymbol = MapContextLocator.getMapContextManager().createSymbol(geomType);

        }

        ISymbolSelector symSel = SymbolSelector.createSymbolSelector(this.highlightSymbol, geomType);

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

        windowManager.showWindow((JComponent)symSel, "_Symbol", WindowManager.MODE.DIALOG);

        this.highlightSymbol = (ISymbol) symSel.getSelectedObject();

    }

    private void doUpdateComponents() {

        this.treeSourceController.setEnabled(true);

        this.cboReport.setEnabled(this.source != null);

        this.txtBufferSize.setEnabled(this.chkZoomToCurrentRow.isSelected());

        if(this.dialog != null){

            boolean enabled = (this.source != null) && (this.getLayoutDocument() != null) && StringUtils.isNotBlank(this.txtIdentifier.getText());

            this.dialog.setButtonEnabled(WindowManager_v2.BUTTON_OK, enabled);

        }

    }

    private void fillCboReport() {

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        DefaultComboBoxModel<LabeledValue<ReportAction>> model = new DefaultComboBoxModel();

        if(this.source == null) {

            this.cboReport.setModel(model);

            return;

        }

        List<ReportAction> reports = dataSwingManager.getReportActions(source, (Predicate<JsonObject>) (JsonObject t) -> LayoutReportActionFactory.isJsonApplicable(t));

        model.addElement(new LabeledValueImpl<>("", null));

        for (ReportAction report : reports) {

            model.addElement(new LabeledValueImpl<>(report.getReportLabel(), report));

        }

        cboReport.setModel(model);

    }

    List<Document> getLayouts() {

        List<Document> layouts = ApplicationLocator.getProjectManager().getCurrentProject().getDocuments(LayoutDocument.class);

        return layouts;

    }

    private void fillCboLayout() {

        DefaultComboBoxModel<LabeledValue<LayoutDocument>> model = new DefaultComboBoxModel();

        List<Document> layouts = getLayouts();

        for (Document layout : layouts) {

            if(layout instanceof LayoutDocument){

                model.addElement(new LabeledValueImpl<>(layout.getName(), (LayoutDocument)layout));

            }

        }

        cboLayout.setModel(model);

        fillCboView();

    }

    private void fillCboView() {

        LayoutDocument layout = getLayoutDocument();

        DefaultComboBoxModel<LabeledValue<String>> model = new DefaultComboBoxModel();

        if (layout != null) {

            int n = 1;

            for (IFFrame frame : layout.getLayoutContext().getAllFFrames()) {

                if (frame instanceof FFrameView) {

                    String tag = frame.getTag();

                    if(StringUtils.startsWith(tag, "#") && !StringUtils.equals(tag, "#"+n)){

                        model.addElement(new LabeledValueImpl<>(tag+" (invalid tag)",tag));

                    } else {

                        if(StringUtils.isBlank(tag)){

                            tag = "#"+n;

                        }

                        model.addElement(new LabeledValueImpl<>(tag,tag));

                    }

                    n++;

                }

            }

        }

        this.cboView.setModel(model);

    }

    private LayoutReportAction getReportAction(){

        LabeledValue<LayoutReportAction> selected = (LabeledValue<LayoutReportAction>)cboReport.getSelectedItem();

        if(selected == null){

            return null;

        }

        return selected.getValue();

    }

    private LayoutDocument getLayoutDocument(){

        LabeledValue<LayoutDocument> selected = (LabeledValue<LayoutDocument>)cboLayout.getSelectedItem();

        if(selected == null){

            return null;

        }

        return selected.getValue();

    }

    private String getViewTag(){

        LabeledValue<String> selected = (LabeledValue<String>)cboView.getSelectedItem();

        if(selected == null){

            return null;

        }

        return selected.getValue();

    }

    public void fetch(ConfigureReportFromLayoutParameters params){

        params.setLayout(this.getLayoutDocument());

        params.setSource(this.source);

        params.setIdentifier(this.txtIdentifier.getText());

        params.setLabel(this.txtLabel.getText());

        params.setCenterToCurrentRow(this.chkCenterToCurrentRow.isSelected());

        params.setZoomToCurrentRow(this.chkZoomToCurrentRow.isSelected());

        double bufferSize = PositiveDoubleDocumentFilter.getValue(this.txtBufferSize);

        params.setBufferSize(bufferSize);

        params.setViewTag(this.getViewTag());

        params.setUseIntervalPdfViewer(this.chkUseInternalPdfViewer.isSelected());

        params.setHighlightRecord(this.chkHighlightRecord.isSelected());

        params.setHighlightSymbol(this.highlightSymbol);

    }

    private void translate() {

        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();

        manager.translate(lblLayout);

        manager.translate(lblSource);

        manager.translate(lblReport);

        manager.translate(lblIdentifier);

        manager.translate(lblLabel);

        manager.translate(lblViewSeparator);

        manager.translate(lblView);

        manager.translate(chkCenterToCurrentRow);

        manager.translate(chkZoomToCurrentRow);

        manager.translate(lblBufferSize);

        manager.translate(chkUseInternalPdfViewer);

        manager.translate(txtBufferSize);

        manager.translate(chkHighlightRecord);

        manager.translate(btnSelectSymbol);

    }

    public boolean doConfigureReportFromLayout(ConfigureReportFromLayoutParameters params) {

        LayoutDocument layout = params.getLayout();

        FeatureStore source = params.getSource();

        String identifier = params.getIdentifier();

        String label = params.getLabel();

        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

        I18nManager i18n = ToolsLocator.getI18nManager();

        if(layout == null){

            dialogs.messageDialog(

                    i18n.getTranslation("_Layout_cant_be_null"), 

                    null,

                    "_Configure_report_from_layout", 

                    JOptionPane.WARNING_MESSAGE);

            return false;

        }

        if(source == null){

            dialogs.messageDialog(

                    i18n.getTranslation("_Source_cant_be_null"), 

                    null,

                    "_Configure_report_from_layout", 

                    JOptionPane.WARNING_MESSAGE);

            return false;

        }

        if(StringUtils.isBlank(identifier)){

            dialogs.messageDialog(

                    i18n.getTranslation("_Identifier_cant_be_null"), 

                    null,

                    "_Configure_report_from_layout", 

                    JOptionPane.WARNING_MESSAGE);

            return false;

        }

        boolean centerToCurrentRow = params.isCenterToCurrentRow();

        boolean zoomToCurrentRow = params.isZoomToCurrentRow();

        double bufferSize = params.getBufferSize();

        boolean highlightRecord = params.isHighlightRecord();

        ISymbol highlightSymbol = params.getHighlightSymbol();

        boolean useInternalPdfViewer = params.isUseIntervalPdfViewer();

        String viewTag = params.getViewTag();

        return doConfigureReportFromLayout(

                source, 

                layout, 

                identifier, 

                label, 

                centerToCurrentRow, 

                zoomToCurrentRow, 

                bufferSize, 

                highlightRecord,

                highlightSymbol,

                viewTag,

                useInternalPdfViewer);

    }

    public boolean doConfigureReportFromLayout(

            FeatureStore store, 

            LayoutDocument layout, 

            String name, 

            String label,

            boolean centerToCurrentRow,

            boolean zoomToCurrentRow,

            double bufferSize,

            boolean highlightRecord,

            ISymbol highlightSymbol,

            String viewTag,

            boolean useInternalPdfViewer

    ) {

        ResourcesStorage.Resource resource = null;

        ResourcesStorage.Resource resourceLayout = null;

        boolean selfContained = layout.isPersistIndependent();

        try {

            ResourcesStorage resources = store.getResourcesStorage();

            String resourceName = getResourceName(resources, name);

            if(resourceName == null){

                resourceName = getNextResourceName(resources, "report");

            }

            String templateName = LayoutReportActionFactory.LAYOUT_REPORT_ACTION_NAME;

            if(StringUtils.contains(resourceName, resources.getSeparator())){

                templateName = StringUtils.replaceIgnoreCase(resourceName, resources.getSeparator()+"report", resources.getSeparator()+LayoutReportActionFactory.LAYOUT_REPORT_ACTION_NAME);

            }

            JsonObjectBuilder jsonBuilder = Json.createObjectBuilder();

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_NAME, name);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_TYPE, LayoutReportActionFactory.LAYOUT_REPORT_ACTION_NAME);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_LABEL, label);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_TEMPLATE_NAME, templateName);

            if(highlightSymbol != null){

                jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_HIGHLIGHT_SYMBOL, this.toString(highlightSymbol));

            }

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_CENTER_TO_CURRENT_ROW, centerToCurrentRow);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_ZOOM_TO_CURRENT_ROW, zoomToCurrentRow);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_BUFFER_SIZE, bufferSize);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_HIGHLIGHT_RECORD, highlightRecord);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_VIEW_TAG, viewTag);

            jsonBuilder.add(LayoutReportActionImpl.LAYOUT_REPORT_USE_INTERNAL_PDF_VIEWER, useInternalPdfViewer);

            resource = resources.getResource(resourceName);

            IOUtils.write(jsonBuilder.toString(), resource.asOutputStream(), StandardCharsets.UTF_8);

            resourceLayout = resources.getResource(templateName);

            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            layout.setPersistIndependent(true);

            PersistentState persistentState = persistenceManager.getState(layout.getMainWindow());

            persistenceManager.saveState(persistentState, resourceLayout.asOutputStream());

            ((JComponent)dialog).setVisible(false);

            return true;

        } catch (Exception ex) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_configure_report_from_layout"), 

                    null,

                    "_Configure_report_from_layout", 

                    JOptionPane.WARNING_MESSAGE);

            return false;

        } finally {

            layout.setPersistIndependent(selfContained);

            IOUtils.closeQuietly(resource);

            IOUtils.closeQuietly(resourceLayout);

        }

    }

    private String toString(ISymbol symbol){

        try {

            if(symbol == null){

                return null;

            }

            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            PersistentState state = persistenceManager.getState(symbol);

            ByteArrayOutputStream out = new ByteArrayOutputStream();

            persistenceManager.saveState(state, out);

            return Hex.encodeHexString(out.toByteArray());

        } catch (Exception ex) {

            throw new RuntimeException("Can't persist symbol", ex);

        }

    }

    private String getNextResourceName(ResourcesStorage resources, String resourceName){

        List<ResourcesStorage.Resource> reports = resources.getResources(resourceName);

        if(reports == null || reports.isEmpty()){

            return resourceName;

        }

        int n = -1;

        for (ResourcesStorage.Resource report : reports) {

            if(StringUtils.contains(report.getName(), resources.getSeparator())){

                String[] s = StringUtils.split(report.getName(), resources.getSeparator());

                n = Math.max(n, Integer.parseInt(s[0]));

            } else {

                n=0;

            }

        }

        if (n < 0) {

            return resourceName;

        }

        n++;

        return String.valueOf(n) + resources.getSeparator() + resourceName;

    }

    private String getResourceName(ResourcesStorage resources, String reportName) {

        try {

            if (resources != null) {

                List<ResourcesStorage.Resource> reportsResources = resources.getResources("report");

                if (reportsResources != null && !reportsResources.isEmpty()) {

                    for (ResourcesStorage.Resource resource : reportsResources) {

                        InputStream is = null;

                        try {

                            is = resource.asInputStream();

                            JsonObject json = javax.json.Json.createReader(is).readObject();

                            String name = json.getString(LayoutReportActionImpl.LAYOUT_REPORT_NAME, null);

                            if(StringUtils.equalsIgnoreCase(name, reportName)){

                                return resource.getName();

                            }

                        } catch (Exception ex) {

                            LOGGER.warn("Can't load report form resource (" + resource.getURL() + ")", ex);

                        } finally {

                            IOUtils.closeQuietly(is);

                        }

                        DisposeUtils.disposeQuietly(resource);

                    }

                }

            }

        } finally {

            DisposeUtils.disposeQuietly(resources);

        }

        return null;

    }

    private void doChangeReport() {

        LayoutReportAction report = getReportAction();

        if(report == null){

            this.txtIdentifier.setText("");

            this.txtLabel.setText("");

        } else {

            this.txtIdentifier.setText(report.getReportName());

            this.txtLabel.setText(report.getReportLabel());

            this.chkCenterToCurrentRow.setSelected(report.isCenterToCurrentRow());

            this.chkZoomToCurrentRow.setSelected(report.isZoomToCurrentRow());

            PositiveDoubleDocumentFilter.setValue(this.txtBufferSize,report.getBufferSize());

            this.chkHighlightRecord.setSelected(report.isHighlightRecord());

            ListElement.setSelected(this.cboView, report.getViewTag());

            this.chkUseInternalPdfViewer.setSelected(report.isUseInternalPdfViewer());

        }

        doUpdateComponents();

    }

    void setDialog(Dialog dialog) {

        this.dialog = dialog;

    }

}