Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.sql.view.list;

import org.openconcerto.sql.Configuration;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLRowAccessor;
import org.openconcerto.sql.model.SQLRowValues;
import org.openconcerto.sql.model.SQLSelect;
import org.openconcerto.sql.model.Where;
import org.openconcerto.sql.request.ComboSQLRequest;
import org.openconcerto.sql.sqlobject.ITextArticleWithCompletionCellEditor;
import org.openconcerto.sql.sqlobject.ITextWithCompletion;
import org.openconcerto.sql.sqlobject.SelectionListener;
import org.openconcerto.sql.sqlobject.SelectionRowListener;
import org.openconcerto.ui.TextAreaRenderer;
import org.openconcerto.utils.cc.ITransformer;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.sql.Types;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import java.util.Vector;

import javax.swing.SwingUtilities;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.table.TableCellEditor;

public class AutoCompletionManager implements SelectionRowListener, SelectionListener {

    private SQLTableElement fromTableElement;
    private RowValuesTable table;
    private TextTableCellEditorWithCompletion editor;
    private int lastSelectedComboId = 1;
    protected boolean optOk, foreign;
    protected boolean disableCompletion;

    private SQLField fillFrom;
    private RowValuesTableModel tableModel;
    ITextWithCompletion t;
    SQLTextComboTableCellEditor textComboCellEdit;

    public AutoCompletionManager(SQLTableElement fromTableElement, SQLField fillFrom, RowValuesTable table, RowValuesTableModel tableModel) {
        this(fromTableElement, fillFrom, table, tableModel, ITextWithCompletion.MODE_CONTAINS, false);
    }

    // FIXME Le validstatechecker est à passer au SQLTableElement
    public AutoCompletionManager(SQLTableElement fromTableElement, SQLField fillFrom, RowValuesTable table, RowValuesTableModel tableModel, int modeCompletion, boolean expandWithShowAs,
            boolean foreign, ValidStateChecker checker) {

        this.foreign = foreign;
        List<String> l = new Vector<String>();

        if (expandWithShowAs) {
            List<SQLField> lSQLFields = Configuration.getInstance().getShowAs().getFieldExpand(fillFrom.getTable());
            for (int i = 0; i < lSQLFields.size(); i++) {
                l.add(lSQLFields.get(i).getName());
            }
        } else {
            l.add(fillFrom.getName());
        }
        ComboSQLRequest req = new ComboSQLRequest(fillFrom.getTable(), l);
        init(fromTableElement, fillFrom, table, tableModel, modeCompletion, req, foreign, checker);

    }

    public AutoCompletionManager(SQLTableElement fromTableElement, SQLField fillFrom, RowValuesTable table, RowValuesTableModel tableModel, int modeCompletion, boolean expandWithShowAs) {
        this(fromTableElement, fillFrom, table, tableModel, modeCompletion, expandWithShowAs, false, new ValidStateChecker());
    }

    public AutoCompletionManager(SQLTableElement fromTableElement, SQLField fillFrom, RowValuesTable table, RowValuesTableModel tableModel, int modeCompletion, ComboSQLRequest req) {
        init(fromTableElement, fillFrom, table, tableModel, modeCompletion, req, false);
    }

    public void init(SQLTableElement fromTableElement, SQLField fillFrom, RowValuesTable table, RowValuesTableModel tableModel, int modeCompletion, ComboSQLRequest req, boolean foreign) {
        init(fromTableElement, fillFrom, table, tableModel, modeCompletion, req, foreign, new ValidStateChecker());
    }

    private ITextArticleWithCompletionCellEditor articleCombo;

    public void init(final SQLTableElement fromTableElement, final SQLField fillFrom, RowValuesTable table, RowValuesTableModel tableModel, int modeCompletion, ComboSQLRequest req, boolean foreign,
            ValidStateChecker validStateChecker) {

        this.tableModel = tableModel;
        this.fromTableElement = fromTableElement;

        this.fillFrom = fillFrom;

        this.table = table;

        TableCellEditor cellEdit = this.fromTableElement.getTableCellEditor(table);
        if (foreign) {
            if (cellEdit instanceof SQLTextComboTableCellEditor) {
                this.textComboCellEdit = (SQLTextComboTableCellEditor) cellEdit;
                textComboCellEdit.addSelectionListener(new PropertyChangeListener() {

                    @Override
                    public void propertyChange(PropertyChangeEvent evt) {

                        int i = textComboCellEdit.getComboSelectedId();
                        if (AutoCompletionManager.this.lastSelectedComboId != i) {
                            if (fromTableElement.getField().getForeignTable().equals(fillFrom.getTable())) {
                                idSelected(i, null);
                            } else {
                                int selectedID = SQLRow.NONEXISTANT_ID;
                                final SQLRow selectedRow = textComboCellEdit.getCombo().getSelectedRow();
                                if (selectedRow != null) {
                                    selectedID = selectedRow.getForeignRow("ID_" + fillFrom.getTable().getName()).getID();
                                }
                                idSelected(selectedID, null);
                            }
                        }
                        AutoCompletionManager.this.lastSelectedComboId = i;
                        System.err.println("editing stopped");
                    }
                });

                textComboCellEdit.addCellEditorListener(new CellEditorListener() {
                    @Override
                    public void editingCanceled(ChangeEvent e) {
                        AutoCompletionManager.this.lastSelectedComboId = textComboCellEdit.getComboSelectedId();
                    }

                    @Override
                    public void editingStopped(ChangeEvent e) {
                        AutoCompletionManager.this.lastSelectedComboId = textComboCellEdit.getComboSelectedId();
                    }
                });

            }
        } else if (cellEdit instanceof ITextArticleWithCompletionCellEditor) {
            this.articleCombo = (ITextArticleWithCompletionCellEditor) cellEdit;
            this.articleCombo.addSelectionListener(this);
        } else {

            this.t = new ITextWithCompletion(req, true);
            this.t.setModeCompletion(modeCompletion);
            this.editor = new TextTableCellEditorWithCompletion(table, this.t, validStateChecker);

            if (this.fillFrom.getType().getType() == Types.VARCHAR) {
                this.t.setLimitedSize(this.fillFrom.getType().getSize());
                this.editor.setLimitedSize(this.fillFrom.getType().getSize());
            }

            this.fromTableElement.setEditor(this.editor);
            this.fromTableElement.setRenderer(new TextAreaRenderer());

            this.t.addSelectionListener(this);
        }
    }

    private HashMap<String, String> fillBy = new LinkedHashMap<String, String>();
    private int lastId = -1;
    private int lastEditingRow = -1;

    public void fill(String string, String string2) {
        this.fillBy.put(string, string2);

    }

    public void idSelected(int id, Object source) {

        // Le Text correspond a un id
        final int rowE = this.table.getEditingRow();
        if (rowE < 0) {
            this.lastEditingRow = rowE;
            return;
        }

        if (this.lastEditingRow == rowE && this.lastId == id) {
            // Evite de reremplir si l'on reselectionne le meme id sur la meme ligne
            return;
        }
        if (id > 1) {
            this.lastId = id;
            this.lastEditingRow = rowE;

            // On arrete l'edition nous meme pour eviter qu'un click externe fasse un cancelEditing
            if (this.table.getCellEditor() != null && !this.foreign) {
                this.table.getCellEditor().stopCellEditing();
            }

            fillWithSelection(null, id, rowE);
        }
    }

    @Override
    public void rowSelected(SQLRowAccessor row, Object source) {
        final int rowE = this.table.getEditingRow();
        if (rowE < 0 || row == null) {
            this.lastEditingRow = rowE;
            return;
        }

        this.lastEditingRow = rowE;

        // On arrete l'edition nous meme pour eviter qu'un click externe fasse un cancelEditing
        if (this.table.getCellEditor() != null && !this.foreign) {
            this.table.getCellEditor().stopCellEditing();
        }
        fillWithSelection(row, SQLRow.NONEXISTANT_ID, rowE);
    }

    private void fillWithSelection(final SQLRowAccessor r, final int id, final int rowE) {

        final SQLRowAccessor rowDest = (rowE >= 0 && rowE <= this.table.getRowCount()) ? this.table.getRowValuesTableModel().getRowValuesAt(rowE) : null;

        new Thread(new Runnable() {
            public void run() {
                // final SQLRowValues rowV = new
                // SQLRowValues(AutoCompletionManager.this.fillFrom.getTable());
                final SQLRow rowV;
                if (r != null) {
                    rowV = r.fetchNewRow(false);
                } else {
                    rowV = AutoCompletionManager.this.fillFrom.getTable().getRow(id);
                }
                // Test pour éviter de perdre la sélection d'un article ayant la même désignation
                // mais un code différent (Problème remonté par Afhymat avec la tabulation)
                if (fillFrom != null && fillFrom.getTable().getName().equals("ARTICLE") && fillFrom.getName().equals("NOM") && rowDest != null && !rowDest.isUndefined()) {
                    SQLRowAccessor rowArt = rowDest.getForeign("ID_ARTICLE");
                    if (rowArt != null && !rowArt.isUndefined() && rowArt.getString("NOM") != null && rowArt.getString("NOM").trim().equalsIgnoreCase(rowV.getString("NOM").trim())) {
                        return;
                    }
                }

                final Set<String> keys = AutoCompletionManager.this.fillBy.keySet();
                // Fill the table model rowvalue with the selected item using the fields defined
                // with 'fill'

                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        for (Iterator<String> iter = keys.iterator(); iter.hasNext();) {
                            String from = iter.next();
                            String to = AutoCompletionManager.this.fillBy.get(from);
                            Object fromV = getValueFrom(rowV, from, rowDest);
                            int column = AutoCompletionManager.this.tableModel.getColumnForField(to);
                            if (column >= 0) {

                                // Request focus
                                if (AutoCompletionManager.this.table.getRowValuesTableModel().getValueAt(rowE, column) == null
                                        || !AutoCompletionManager.this.table.getRowValuesTableModel().getValueAt(rowE, column).equals(fromV)) {
                                    AutoCompletionManager.this.table.getRowValuesTableModel().setValueAt(fromV, rowE, column);
                                    // Test Only if not foreign --> Bug avec le
                                    // sqltextcombocelleditor, si test edit cellAt -> fire
                                    // idSelected
                                    // -1 sur la combo ce qui entraine une déselection (Bug Remonté
                                    // par SA Poulignier)
                                    if (!AutoCompletionManager.this.foreign && AutoCompletionManager.this.table.getEditingColumn() == column
                                            && AutoCompletionManager.this.table.getEditingRow() == rowE) {
                                        AutoCompletionManager.this.table.editingCanceled(null);
                                        AutoCompletionManager.this.table.setColumnSelectionInterval(column, column);
                                        AutoCompletionManager.this.table.setRowSelectionInterval(rowE, rowE);
                                        if (AutoCompletionManager.this.table.editCellAt(rowE, column)) {
                                            if (AutoCompletionManager.this.table.getEditorComponent() != null) {
                                                AutoCompletionManager.this.table.getEditorComponent().requestFocusInWindow();
                                            }
                                        }
                                    }
                                }
                            } else {
                                // Not in the table
                                AutoCompletionManager.this.table.getRowValuesTableModel().putValue(fromV, rowE, to);
                            }
                        }

                        AutoCompletionManager.this.table.resizeAndRepaint();
                    }
                });
            }
        }).start();
    }

    public Set<String> getFieldsFrom() {
        return this.fillBy.keySet();
    }

    public String getToField(String fromField) {
        return this.fillBy.get(fromField);
    }

    public void fillRowValues(SQLRowAccessor from, Set<String> fields, SQLRowValues to) {
        for (String fromField : fields) {
            String toField = AutoCompletionManager.this.fillBy.get(fromField);
            to.put(toField, getValueFrom(from.asRow(), fromField, to));
        }
    }

    protected Object getValueFrom(SQLRow row, String field, SQLRowAccessor rowDest) {
        return row.getObject(field);
    }

    public void setSelectTransformer(ITransformer<SQLSelect, SQLSelect> selTrans) {
        if (this.t != null) {
            this.t.setSelectTransformer(selTrans);
        } else if (this.textComboCellEdit != null) {
            this.textComboCellEdit.setSelectTransformer(selTrans);
        } else if (this.articleCombo != null) {
            this.articleCombo.setSelectTransformer(selTrans);
        }
    }

    public void setWhere(Where w) {
        if (this.t != null) {
            this.t.setWhere(w);
        } else if (this.textComboCellEdit != null) {
            this.textComboCellEdit.setWhere(w);
        } else if (this.articleCombo != null) {
            this.articleCombo.setWhere(w);
        }
    }

    public void setFillWithField(String s) {
        this.t.setFillWithField(s);
    }
}