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.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.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.app.ApplicationLocator;

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

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

            @Override

            public void actionPerformed(ActionEvent e) {

                doUpdateComponents();

            }

        });

        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 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.setSelectCurrentRow(this.chkSelectCurrentRow.isSelected());

        params.setViewTag(this.getViewTag());

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

    }

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

        manager.translate(chkUseInternalPdfViewer);

        manager.translate(txtBufferSize);

    }

    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 selectCurrentRow = params.isSelectCurrentRow();

        boolean useInternalPdfViewer = params.isUseIntervalPdfViewer();

        String viewTag = params.getViewTag();

        return doConfigureReportFromLayout(

                source, 

                layout, 

                identifier, 

                label, 

                centerToCurrentRow, 

                zoomToCurrentRow, 

                bufferSize, 

                selectCurrentRow,

                viewTag,

                useInternalPdfViewer);

    }

    public boolean doConfigureReportFromLayout(

            FeatureStore store, 

            LayoutDocument layout, 

            String name, 

            String label,

            boolean centerToCurrentRow,

            boolean zoomToCurrentRow,

            double bufferSize,

            boolean selectCurrentRow,

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

            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_SELECT_CURRENT_ROW, selectCurrentRow);

            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 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.chkSelectCurrentRow.setSelected(report.isSelectCurrentRow());

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

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

        }

        doUpdateComponents();

    }

    void setDialog(Dialog dialog) {

        this.dialog = dialog;

    }

}