gvSIG projects pool

package org.gvsig.topology.swing.impl;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListSelectionModel;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JMenuItem;

import javax.swing.JPopupMenu;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.TableModel;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynform.DynFormLocator;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

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

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.task.TaskStatus;

import org.gvsig.topology.lib.api.TopologyLocator;

import org.gvsig.topology.lib.api.TopologyPlan;

import org.gvsig.topology.lib.api.TopologyReport;

import org.gvsig.topology.lib.api.TopologyReportLine;

import org.gvsig.topology.lib.api.TopologyReportLineSet;

import org.gvsig.topology.lib.api.TopologyRule;

import org.gvsig.topology.lib.api.TopologyRuleAction;

import org.gvsig.topology.lib.api.TopologyRuleFactory;

import org.gvsig.topology.swing.api.JTopologyReport;

import org.gvsig.topology.swing.api.TopologySwingLocator;

import org.gvsig.topology.swing.api.TopologySwingServices;

import org.gvsig.topology.swing.api.TopologySwingServices.WorkingAreaChangedListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultJTopologyReport

        extends DefaultJTopologyReportView

        implements JTopologyReport {

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

    private ListSelectionModel selection;

    private class TopologyRuleActionParametersListener implements ActionListener {

        private final TopologyRule rule;

        private final List<TopologyReportLine> lines;

        private final TopologyRuleAction action;

        private final JDynForm form;

        public TopologyRuleActionParametersListener(

                TopologyRule rule,

                List<TopologyReportLine> lines,

                TopologyRuleAction action,

                JDynForm form

        ) {

            this.action = action;

            this.lines = lines;

            this.rule = rule;

            this.form = form;

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            doExecuteRuleAction(rule, lines, action, form);

        }

    }

    private class TopologyRuleActionListener implements ActionListener {

        private final TopologyRule rule;

        private final List<TopologyReportLine> lines;

        private final TopologyRuleAction action;

        public TopologyRuleActionListener(

                TopologyRule rule,

                List<TopologyReportLine> lines,

                TopologyRuleAction action

        ) {

            this.action = action;

            this.lines = lines;

            this.rule = rule;

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            if (this.action.hasParameters()) {

                doShowActionParametersPanel(this.rule, this.lines, this.action);

            } else {

                doExecuteRuleAction(rule, lines, action, null);

            }

        }

    }

    private ReportTable linesModel;

    private final TopologySwingServices services;

    private TaskStatusController taskStatusController;

    private TopologyPlan plan;

    private WorkingAreaChangedListener workingAreaChangedListener;

    public DefaultJTopologyReport(TopologyPlan plan) {

        this.services = TopologySwingLocator.getTopologySwingManager().getDefaultServices();

        this.initComponents();

    }

    private void initComponents() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        this.selection = this.tblErrors.getSelectionModel();

        this.linesModel = new ReportTable();

        this.workingAreaChangedListener = new WorkingAreaChangedListener() {

            @Override

            public void workingAreaChanged(Envelope workingArea) {

                doUpdateFilter();

            }

        };

        this.tblErrors.setModel(this.linesModel);

        this.tblErrors.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);

        this.btnZoomGeometry.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doZoomGeometry();

            }

        });

        this.btnZoomError.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doZoomError();

            }

        });

        this.btnCenterGeometry.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doCenterGeometry();

            }

        });

        this.btnCenterError.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doCenterError();

            }

        });

        this.btnRefresh.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doExecutePlan();

            }

        });

        this.tblErrors.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                doRowSelected();

            }

        });

        this.tblErrors.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                if (e.getButton() == MouseEvent.BUTTON1 && e.getClickCount() == 2) {

                    doCenterError();

                }

            }

        });

        this.btnActions.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doSelectAction();

            }

        });

        this.btnParametersCancel.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                tabData.setEnabledAt(0, true);

                tabData.setEnabledAt(1, false);

                tabData.setSelectedIndex(0);

                pnlParameters.removeAll();

            }

        });

        this.btnShowErrors.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUpdateFilter();

            }

        });

        this.btnShowExceptions.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUpdateFilter();

            }

        });

        this.btnVisibleExtentOnly.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUpdateFilter();

            }

        });

        this.btnShowForm.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                services.setShowFormWhenEdit(btnShowForm.isSelected());

            }

        });

        this.btnEraseErrorMarks.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                services.addError(null);

            }

        });

        DefaultComboBoxModel<ListElement<TopologyRuleFactory>> modelRules = new DefaultComboBoxModel<>();

        modelRules.addElement(new ListElement<>(i18n.getTranslation("_Any_rule"), (TopologyRuleFactory) null));

        List<TopologyRuleFactory> factories = TopologyLocator.getTopologyManager().getRuleFactories();

        for (TopologyRuleFactory factory : factories) {

            modelRules.addElement(new ListElement<>(factory.getName(), factory));

        }

        this.cboRules.setModel(modelRules);

        this.cboRules.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                // Llama al invokeLater para poder debugguear

                SwingUtilities.invokeLater(new Runnable() {

                    @Override

                    public void run() {

                        doUpdateFilter();

                    }

                });

            }

        });

        this.taskStatusController = ToolsSwingLocator.getTaskStatusSwingManager().createTaskStatusController(

                null,

                this.lblTaskStatusTitle,

                this.lblTaskStatusMessage,

                this.pbTaskStatusProgress,

                this.btnTaskStatusCancel,

                null

        );

        this.translate();

        this.setPreferredSize(new Dimension(700, 200));

        this.btnShowErrors.setSelected(false);

        this.btnShowExceptions.setSelected(false);

        this.btnVisibleExtentOnly.setSelected(false);

        this.tabData.setEnabledAt(1, false);

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

        IconTheme theme = ToolsSwingLocator.getIconThemeManager().getDefault();

        if (theme.exists(name)) {

            return theme.get(name);

        }

        URL url = this.getClass().getResource("/" + imageName);

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    }

    private void translate() {

        ToolsSwingManager tsm = ToolsSwingLocator.getToolsSwingManager();

        tsm.translate(this.btnActions);

        tsm.translate(this.btnCenterError);

        tsm.translate(this.btnCenterGeometry);

        tsm.translate(this.btnRefresh);

        tsm.translate(this.btnShowErrors);

        tsm.translate(this.btnShowExceptions);

        tsm.translate(this.btnZoomError);

        tsm.translate(this.btnZoomGeometry);

        tsm.translate(this.btnEraseErrorMarks);

        tsm.translate(this.btnVisibleExtentOnly);

        tsm.translate(this.btnParametersAccept);

        tsm.translate(this.btnParametersCancel);

        tsm.translate(this.btnShowForm);

        tsm.translate(this.lblShow);

        tsm.translate(this.tabData);

    }

    @Override

    public void put(TopologyPlan plan) {

        this.plan = plan;

        this.taskStatusController.bind(this.plan.getTaskStatus());

        this.plan.getTaskStatus().addObserver(new Observer() {

            @Override

            public void update(Observable o, Object o1) {

                doTaskStatusUpdated(o, o1);

            }

        });

        this.linesModel.setReport(plan.getReport());

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    private void doUpdateFilter() {

        this.linesModel.setFilter(this.getFilter());

    }

    private String getFilter() {

        ExpressionBuilder builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder();

        TopologyRuleFactory ruleFactory = (TopologyRuleFactory) ListElement.getSelected(cboRules);

        if (ruleFactory != null) {

            builder.setValue(

                    builder.eq(

                            builder.column(TopologyReport.RULE_ID),

                            builder.constant(ruleFactory.getId())

                    )

            );

        }

        if (this.btnShowErrors.isSelected()) {

            if (btnShowExceptions.isSelected()) {

                builder.and(

                        builder.or(

                                builder.column(TopologyReport.IS_ERROR),

                                builder.column(TopologyReport.IS_EXCEPTION)

                        )

                );

            } else {

                builder.and(

                        builder.column(TopologyReport.IS_ERROR)

                );

            }

        } else if (btnShowExceptions.isSelected()) {

            builder.and(

                    builder.column(TopologyReport.IS_EXCEPTION)

            );

        }

        if (this.btnVisibleExtentOnly.isSelected()) {

            Envelope workingArea = this.services.getWorkingArea();

            if (workingArea != null) {

                builder.and(

                        builder.ST_Intersects(

                                builder.column(TopologyReport.GEOMETRY),

                                builder.geometry(workingArea.getGeometry())

                        )

                );

            }

            this.services.addWorkingAreaChangedListener(this.workingAreaChangedListener);

        } else {

            this.services.removeWorkingAreaChangedListener(this.workingAreaChangedListener);

        }

        if (builder.getValue() == null) {

            return null;

        }

        return builder.toString();

    }

    private void doExecutePlan() {

        Thread th = new Thread(new Runnable() {

            @Override

            public void run() {

                plan.execute();

            }

        }, "TopologyPlan-" + plan.getName());

        th.start();

    }

    private void doTaskStatusUpdated(final Observable observable, final Object notification) {

        if (observable != null && !(observable instanceof TaskStatus)) {

            return;

        }

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                public void run() {

                    doTaskStatusUpdated(observable, notification);

                }

            });

            return;

        }

        TaskStatus taskStatus = (TaskStatus) observable;

        if (taskStatus == null || !taskStatus.isRunning()) {

            this.lblTaskStatusTitle.setVisible(false);

            this.lblTaskStatusMessage.setVisible(false);

            this.pbTaskStatusProgress.setVisible(false);

            this.btnTaskStatusCancel.setVisible(false);

            this.btnRefresh.setEnabled(true);

            I18nManager i18n = ToolsLocator.getI18nManager();

            message(i18n.getTranslation("_Errors") + ": " + this.linesModel.getRowCount());

            return;

        }

        if (!this.pbTaskStatusProgress.isVisible()) {

            this.lblTaskStatusTitle.setVisible(true);

            this.lblTaskStatusMessage.setVisible(true);

            this.pbTaskStatusProgress.setVisible(true);

            this.btnTaskStatusCancel.setVisible(true);

            this.btnRefresh.setEnabled(false);

        }

    }

    private void message(String msg) {

        this.lblTaskStatusTitle.setText(msg);

        this.lblTaskStatusTitle.setVisible(true);

    }

    private void doSelectAction() {

        int n = this.tblErrors.getSelectedRow();

        if (n < 0) {

            return;

        }

        int[] selectedRows = this.tblErrors.getSelectedRows();

        TopologyRule rule = this.linesModel.getLine(selectedRows[0]).getRule();

        List<TopologyRuleAction> actions = rule.getActions();

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

            return;

        }

        List<TopologyReportLine> lines = new ArrayList<>();

        for (int selectedRow : selectedRows) {

            TopologyReportLine line = this.linesModel.getLine(selectedRow);

            if (line.getRule() == rule) {

                lines.add(line);

            }

        }

        JPopupMenu menu = new JPopupMenu();

        for (TopologyRuleAction action : actions) {

            JMenuItem item;

            if (action.hasParameters()) {

                item = new JMenuItem(action.getName() + "...");

            } else {

                item = new JMenuItem(action.getName());

            }

            item.addActionListener(new TopologyRuleActionListener(rule, lines, action));

            if (lines.size() > 1 && action.hasParameters()) {

                item.setEnabled(false);

            }

            menu.add(item);

        }

        menu.show(this.btnActions, 0, this.btnActions.getHeight());

    }

    private void doExecuteRuleAction(

            TopologyRule rule,

            List<TopologyReportLine> lines,

            TopologyRuleAction action,

            JDynForm form

    ) {

        DynObject parameters = null;

        if (form != null) {

            parameters = action.createParameters();

            if (parameters != null) {

                form.getValues(parameters);

            }

        }

        for (TopologyReportLine line : lines) {

            action.execute(rule, line, parameters);

        }

        this.tabData.setEnabledAt(0, true);

        this.tabData.setEnabledAt(1, false);

        this.tabData.setSelectedIndex(0);

        this.pnlParameters.removeAll();

        this.services.addError(null);

    }

    private void doShowActionParametersPanel(

            TopologyRule rule,

            List<TopologyReportLine> lines,

            TopologyRuleAction action

    ) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        this.tabData.setEnabledAt(0, false);

        this.tabData.setEnabledAt(1, true);

        this.tabData.setSelectedIndex(1);

        try {

            JDynForm form = null;

            this.lblActionTitle.setText(

                    "<html>"

                    + i18n.getTranslation("_Rule") + ": <b>"

                    + rule.getName() + "</b>, "

                    + i18n.getTranslation("_Action") + ": <b>"

                    + action.getName() + "</b></html>"

            );

            this.lblActionDescription.setText("<html>" + action.getShortDescription() + "</html>");

            DynObject parameters = action.createParameters();

            if (parameters != null) {

                form = DynFormLocator.getDynFormManager().createJDynForm(parameters);

                if (form != null) {

                    this.pnlParameters.setLayout(new BorderLayout());

                    this.pnlParameters.removeAll();

                    this.pnlParameters.add(form.asJComponent(), BorderLayout.CENTER);

                    this.pnlParameters.revalidate();

                    this.pnlParameters.repaint();

                }

            }

            this.btnParametersAccept.addActionListener(

                    new TopologyRuleActionParametersListener(rule, lines, action, form)

            );

        } catch (Exception ex) {

            LOGGER.warn("Can't show action parameters panel.", ex);

        }

    }

    private void doZoomGeometry() {

        int n = this.tblErrors.getSelectedRow();

        if (n < 0) {

            return;

        }

        TopologyReportLine line = this.linesModel.getLine(n);

        Geometry geom = line.getGeometry();

        this.services.zoomTo(geom.getEnvelope());

    }

    private void doZoomError() {

        int n = this.tblErrors.getSelectedRow();

        if (n < 0) {

            return;

        }

        TopologyReportLine line = this.linesModel.getLine(n);

        Geometry geom = line.getError();

        if (geom == null) {

            geom = line.getGeometry();

            services.addError(null);

        } else {

            services.addError(geom);

        }

        this.services.zoomTo(geom.getEnvelope());

    }

    private void doCenterGeometry() {

        try {

            int n = this.tblErrors.getSelectedRow();

            if (n < 0) {

                return;

            }

            TopologyReportLine line = this.linesModel.getLine(n);

            Geometry geom = line.getGeometry();

            this.services.centerTo(geom.centroid());

        } catch (Exception ex) {

            LOGGER.warn("Can't center topology error", ex);

        }

    }

    private void doCenterError() {

        try {

            int n = this.tblErrors.getSelectedRow();

            if (n < 0) {

                return;

            }

            TopologyReportLine line = this.linesModel.getLine(n);

            Geometry geom = line.getError();

            if (geom == null) {

                geom = line.getGeometry();

                services.addError(null);

            } else {

                services.addError(geom);

            }

            this.services.centerTo(geom.centroid());

        } catch (Exception ex) {

            LOGGER.warn("Can't center topology error", ex);

        }

    }

    private void doRowSelected() {

        try {

            int n = this.tblErrors.getSelectedRow();

            if (n < 0) {

                return;

            }

            TopologyReportLine line = this.linesModel.getLine(n);

            if (line.getFeature1() == null) {

                return;

            }

            this.services.addError(null);

            FeatureSelection selection = line.getDataSet1().getFeatureStore().getFeatureSelection();

            selection.deselectAll();

            selection.select(line.getFeature1());

        } catch (Exception ex) {

            LOGGER.warn("Can't select topology error", ex);

        }

    }

    private class ReportTable implements TableModel {

        private TopologyReport report;

        private TopologyReportLineSet lines;

        private final String[] columnNames;

        private final Class[] columnClasses;

        private final Set<TableModelListener> tableListeners;

        private final ChangeListener reportListener;

        private String lastFilter;

        public ReportTable() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.report = null;

            this.lines = null;

            this.tableListeners = new HashSet<>();

            this.columnNames = new String[]{

                i18n.getTranslation("_Rule"),

                i18n.getTranslation("_Dataset1"),

                i18n.getTranslation("_Dataset2"),

                i18n.getTranslation("_Exception"),

                i18n.getTranslation("_Description")

            };

            this.columnClasses = new Class[]{

                String.class,

                String.class,

                String.class,

                Boolean.class,

                String.class

            };

            this.reportListener = new ChangeListener() {

                @Override

                public void stateChanged(final ChangeEvent e) {

                    if (!SwingUtilities.isEventDispatchThread()) {

                        SwingUtilities.invokeLater(new Runnable() {

                            @Override

                            public void run() {

                                stateChanged(e);

                            }

                        });

                        return;

                    }

                    fireTableChanged();

                }

            };

        }

        public void setReport(TopologyReport report) {

            if (this.report != null) {

                this.report.removeChangeListener(this.reportListener);

            }

            this.report = report;

            this.lines = this.report;

            this.lines.addChangeListener(this.reportListener);

        }

        public void setFilter(String filter) {

            if (StringUtils.equals(filter, this.lastFilter)) {

                return;

            }

            this.lines = this.report.getLineSet(filter);

            this.lines.addChangeListener(this.reportListener);

            this.lastFilter = filter;

            this.fireTableChanged();

        }

        public TopologyReport getReport() {

            return this.report;

        }

        @Override

        public int getRowCount() {

            if (this.lines == null) {

                return 0;

            }

            return this.lines.size();

        }

        @Override

        public int getColumnCount() {

            return 5;

        }

        @Override

        public String getColumnName(int columnIndex) {

            return this.columnNames[columnIndex];

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            return this.columnClasses[columnIndex];

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            return false;

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            if (this.lines == null) {

                return "";

            }

            TopologyReportLine line = this.lines.get(rowIndex);

            switch (columnIndex) {

                case 0:

                    return line.getRule().getName();

                case 1:

                    return line.getDataSet1().getName();

                case 2:

                    if (line.getDataSet2() == null) {

                        return "";

                    }

                    return line.getDataSet2().getName();

                case 3:

                    return line.isException();

                case 4:

                    return line.getDescription();

                default:

                    return "???";

            }

        }

        @Override

        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

        }

        @Override

        public void addTableModelListener(TableModelListener l) {

            this.tableListeners.add(l);

        }

        @Override

        public void removeTableModelListener(TableModelListener l) {

            this.tableListeners.remove(l);

        }

        private void fireTableChanged() {

            saveCurrentSelection();

            for (TableModelListener tableListener : this.tableListeners) {

                tableListener.tableChanged(new TableModelEvent(this));

            }

            restoreCurrentSelection();

        }

        public TopologyReportLine getLine(int lineNum) {

            return this.lines.get(lineNum);

        }

    }

    private void saveCurrentSelection() {

        this.tblErrors.setSelectionModel(new DefaultListSelectionModel());

    }

    private void restoreCurrentSelection() {

        this.tblErrors.setSelectionModel(this.selection);

    }

}