Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.featuretype;

import java.awt.event.ActionEvent;

import java.util.Iterator;

import javax.swing.JButton;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.event.ListSelectionEvent;

import org.apache.commons.lang3.ArrayUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

/**

 *

 * @author gvSIG Team

 * @param <T>

 */

public class DefaultAggregateController<T> implements AggregateController<T> {

    private final JTable table;

    private final JButton btnModify;

    private final JButton btnDiscard;

    private final JButton btnAccept;

    private final JButton btnNew;

    private final JButton btnDelete;

    private final AggregateItemController<T> itemController;

    private AggregateModel<T> model;

    private boolean canCreate;

    private boolean canModify;

    private boolean canDelete;

    private ChangeListenerHelper changeListenerHelper;

    private int currentRow;

    private boolean editingItem;

    private boolean newItem;

    public DefaultAggregateController(

            JTable table,

            JButton btnFormFieldModify,

            JButton btnFormFieldDiscard,

            JButton btnFormFieldAccept,

            JButton btnNew,

            JButton btnDelete,

            AggregateItemController<T> itemController

    ) {

        this.table = table;

        this.btnModify = btnFormFieldModify;

        this.btnDiscard = btnFormFieldDiscard;

        this.btnAccept = btnFormFieldAccept;

        this.btnNew = btnNew;

        this.btnDelete = btnDelete;

        this.itemController = itemController;

        this.model = EMPTY_MODEL;

        this.editingItem = false;

        this.newItem = false;

        this.currentRow = -1;

        initComponents();

    }

    private void initComponents() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        this.changeListenerHelper = swingManager.createChangeListenerHelper();

        swingManager.translate(this.btnAccept);

        swingManager.translate(this.btnDiscard);

        swingManager.translate(this.btnModify);

        swingManager.translate(this.btnNew);

        swingManager.translate(this.btnDelete);

        this.table.setModel(this.model);

        this.table.getSelectionModel().addListSelectionListener((ListSelectionEvent e) -> {

            if (e.getValueIsAdjusting()) {

                return;

            }

            doChangeItemSelection();

        });

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

            modifyCurrentItem();

        });

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

            discardModificactions();

        });

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

            acceptModifications();

        });

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

            newItem();

        });

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

            deleteCurrentItem();

        });

    }

    @Override

    public void setModel(AggregateModel<T> model) {

        this.model = model;

        this.table.setModel(model);

        this.currentRow = -1;

        this.newItem = false;

        this.setEditing(false);

    }

    @Override

    public AggregateModel<T> getModel() {

        return this.model;

    }

    @Override

    public AggregateItemController<T> getItemController() {

        return this.itemController;

    }

    @Override

    public int getCurrentRow() {

        return currentRow;

    }

    private void doChangeItemSelection() {

        int row = this.table.getSelectedRow();

        if (row < 0) {

            return;

        }

        if (this.editingItem) {

            if (row != this.currentRow) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                JOptionPane.showMessageDialog(

                        this.table,

                        i18n.getTranslation("_Before_changing_selected_item_accept_or_discard_the_changes"),

                        i18n.getTranslation("_Warning"),

                        JOptionPane.WARNING_MESSAGE

                );

                this.setCurrentRow(this.currentRow);

            }

            return;

        }

        this.setCurrentRow(row);

    }

    @Override

    public void newItem() {

        this.setCurrentRow(-1);

        this.setEditing(true);

        this.newItem = true;

        this.changeListenerHelper.fireEvent();

    }

    @Override

    public void modifyCurrentItem() {

        int row = this.currentRow;

        if (row < 0) {

            return;

        }

        this.setCurrentRow(row);

        this.setEditing(true);

        this.newItem = false;

        this.changeListenerHelper.fireEvent();

    }

    @Override

    public void deleteCurrentItem() {

        int row = this.currentRow;

        int[] rows = this.table.getSelectedRows();

        int n = 0;

        Iterator<T> it = model.iterator();

        while (it.hasNext()) {

            if (ArrayUtils.contains(rows, n++)) {

                it.remove();

            }

        }

        this.setEditing(false);

        this.setCurrentRow(row);

        this.table.updateUI();

        this.changeListenerHelper.fireEvent();

    }

    @Override

    public void acceptModifications() {

        if( !this.editingItem ) {

            return;

        }

        if (this.newItem) {

            T item = this.model.createItem();

            if (this.itemController.fetch(item)) {

                this.model.addItem(item);

                this.setEditing(false);

                this.setCurrentRow(this.model.getRowCount());

                this.newItem = false;

            }

        } else {

            int row = this.currentRow;

            if (row < 0) {

                return;

            }

            T item = this.model.get(row);

            if (this.itemController.fetch(item)) {

                this.setEditing(false);

                this.setCurrentRow(row);

            }

        }

        this.changeListenerHelper.fireEvent();

    }

    @Override

    public void discardModificactions() {

        if( !this.editingItem ) {

            return;

        }

        int row = this.currentRow;

        if (row < 0) {

            return;

        }

        this.setEditing(false);

        this.setCurrentRow(row);

        this.newItem = false;

        this.changeListenerHelper.fireEvent();

    }

    private void setEditing(boolean editing) {

        this.editingItem = editing;

        this.itemController.setEnabled(editing);

        this.btnAccept.setEnabled(this.canModify() && editing);

        this.btnDiscard.setEnabled(editing);

        this.btnModify.setEnabled(this.canModify() && !editing);

        this.btnDelete.setEnabled(this.canDelete() && !editing);

        if( this.currentRow>=0 ) {

            this.btnNew.setEnabled(this.canCreate() && !editing);

        } else {

            this.btnNew.setEnabled(false);

        }

    }

    @Override

    public boolean isEditing() {

        return this.editingItem;

    }

    @Override

    public void setCurrentRow(int row) {

        if( this.editingItem ) {

            return;

        }

        if( row<0 ) {

            this.table.getSelectionModel().removeIndexInterval(0, this.model.getRowCount()-1);

            this.itemController.clean();

            return;

        } 

        if (row >= this.table.getRowCount()) {

            row = this.table.getRowCount() - 1;

        }

        T item = this.model.get(row);

        this.itemController.put(item);

        this.currentRow = row;

        this.table.getSelectionModel().setSelectionInterval(row, row);

        this.table.scrollRectToVisible(this.table.getCellRect(row, 0, true));

    }

    @Override

    public void setCanCreate(boolean canCreate) {

        this.canCreate = canCreate;

    }

    @Override

    public void setCanModify(boolean canModify) {

        this.canModify = canModify;

    }

    @Override

    public void setCanDelete(boolean canDelete) {

        this.canDelete = canDelete;

    }

    @Override

    public boolean canCreate() {

        return this.canCreate;

    }

    @Override

    public boolean canModify() {

        return this.canModify;

    }

    @Override

    public boolean canDelete() {

        return this.canDelete;

    }

}