Application: gvSIG desktop

/*

 * 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.updatetable;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import javax.swing.AbstractCellEditor;

import javax.swing.ImageIcon;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.DefaultTableColumnModel;

import javax.swing.table.TableCellEditor;

import javax.swing.table.TableColumn;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang.StringUtils;

import org.gvsig.app.extension.copytable.StoresRepositoryController;

import static org.gvsig.app.extension.updatetable.UpdateTableProcessParameters.BATCHUPDATE_PROCESS_ALL;

import static org.gvsig.app.extension.updatetable.UpdateTableProcessParameters.BATCHUPDATE_PROCESS_EDITEDS;

import static org.gvsig.app.extension.updatetable.UpdateTableProcessParameters.BATCHUPDATE_PROCESS_SELECTION;

import org.gvsig.app.extension.updatetable.UpdateTableProcessParameters.ProcessFieldParameters;

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.expressionevaluator.swing.JExpressionPicker;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.featuretable.SimpleFeaturesTableModel;

import org.gvsig.fmap.dal.swing.featuretype.AttributeDescriptorPickerController;

import org.gvsig.fmap.dal.swing.featuretype.FeatureAttributesSelectionPanel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.i18n.I18nManager;

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.bookmarkshistory.ActionEventWithCurrentValue;

import static org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue.ID_GETVALUE;

import static org.gvsig.tools.swing.api.bookmarkshistory.ActionEventWithCurrentValue.ID_SETVALUE;

import org.gvsig.tools.swing.api.bookmarkshistory.BookmarksController;

import org.gvsig.tools.swing.api.bookmarkshistory.HistoryController;

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

import org.gvsig.tools.swing.api.task.TaskStatusController;

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.swing.icontheme.IconTheme;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 *

 * @author jjdelcerro

 */

public class UpdateTablePanelImpl extends UpdateTablePanelView {

    private static final String BOOKMARKSANDHISTORY_NAME = "UpdateTablePanel";

    private static final String CONFIGURABLE_PANEL_ID = "UpdateTablePanel";

    private FeatureStore table;

    private ExpressionPickerController pickerTableFilter;

    private DefaultTableColumnModel fieldsColumnModel;

    private SimpleTaskStatus taskStatus;

    private TaskStatusController status;

    private List<String> previewColumns;

    private final Bookmarks bookmarks;

    private final History history;

    private BookmarksController bookmarksController;

    private HistoryController historyController;

    private StoresRepositoryController treeTableController;

    private class FeatureAttributeCellEditor extends AbstractCellEditor implements TableCellEditor {

        private final AttributeDescriptorPickerController picker;

        private final JComboBox combo;

        public FeatureAttributeCellEditor() {

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            this.combo = new JComboBox();

            this.picker = dataSwingManager.createAttributeDescriptorPickerController(this.combo);

        }

        @Override

        public Component getTableCellEditorComponent(JTable jtable, Object value, boolean isSelected, int row, int column) {

            if( value == null ) {

                this.picker.clean();

                return this.combo;

            }

            this.picker.setFeatureType(table.getDefaultFeatureTypeQuietly());

            this.picker.setAllowNull(true);

            this.picker.set(Objects.toString(value,"")); 

            return this.combo;

        }

        @Override

        public Object getCellEditorValue() {

            return this.picker.getName();

        }        

    }

    private class ExpressionCellEditor extends AbstractCellEditor implements TableCellEditor {

        private final JExpressionPicker picker;

        public ExpressionCellEditor() {

            ExpressionEvaluatorSwingManager manager = ExpressionEvaluatorSwingLocator.getManager();

            this.picker = manager.createJExpressionPicker();

            this.picker.removeBorder();

        }

        @Override

        public Component getTableCellEditorComponent(JTable jtable, Object value, boolean isSelected, int row, int column) {

            try {

                DataSwingManager manager = DALSwingLocator.getDataSwingManager();

                manager.configureExpressionBuilder(picker.getConfig(), table);

                if( value == null ) {

                    this.picker.setExpression(null);

                } else {

                    this.picker.setExpression(ExpressionUtils.createExpression((String) value));

                }

                return this.picker.asJComponent();

            } catch(Exception ex) {

                return new JLabel();

            }

        }

        @Override

        public Object getCellEditorValue() {

            Expression exp = this.picker.getExpression();

            if( exp==null ) {

                return null;

            }

            return exp.getPhrase();

        }        

    }

    private class MyTableModel extends AbstractTableModel implements Iterable<MyTableModel.Row>{

        private final List<Row> rows;

        private final String[] columnNames;

        private final Class[] columnClass;

        private final FeatureType tableType;

        private class Row {

            String attrname;

            String expression;

            boolean update;

            public Object get(int index) {

                switch(index) {

                    case 0:

                        return update;

                    case 1:

                        return attrname;

                    case 2:

                        return expression;

                    default:

                        return null;

                }

            }

            public void set(int index, Object value) {

                switch(index) {

                    case 0:

                        this.update = (boolean) value;

                        break;

                    case 1:

                        this.attrname = (String) value;

                        break;

                    case 2:

                        this.expression = (String) value;

                        break;

                    default:

                        break;

                }

            }

        }

        public MyTableModel() {

            this.rows = new ArrayList<>();

            this.tableType = table.getDefaultFeatureTypeQuietly();

            for (FeatureAttributeDescriptor targetAttr : tableType) {

                Row row = new Row();

                row.attrname = targetAttr.getName();

                row.expression = null;

                if( targetAttr.isAutomatic() || targetAttr.isReadOnly() || targetAttr.isPrimaryKey() ) {

                    row.update = false;

                } else {

                    row.update = true;

                }

                this.rows.add(row);

            }

            this.columnNames = new String[] {

                "Actualizarxxxxx",

                "Campo",

                "Expresion"

            };

            this.columnClass = new Class[] {

                Boolean.class,

                String.class,

                String.class

            };

        }

        @Override

        public String getColumnName(int column) {

            return this.columnNames[column];

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            return this.columnClass[columnIndex];

        }

        @Override

        public int getRowCount() {

            return this.rows.size();

        }

        @Override

        public int getColumnCount() {

            return 3;

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            return this.rows.get(rowIndex).get(columnIndex);

        }

        @Override

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

            this.rows.get(rowIndex).set(columnIndex, aValue);

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            FeatureAttributeDescriptor attrdesc = this.tableType.getAttributeDescriptor(rowIndex);

            if( attrdesc == null ) {

                return false;

            }

            if( attrdesc.isAutomatic() || attrdesc.isReadOnly() || attrdesc.isPrimaryKey() ) {

                return false;

            }

            switch(columnIndex) {

                case 0:

                case 1:

                case 2:

                default:

                    return true;

            }

        }

        @Override

        public Iterator<Row> iterator() {

            return this.rows.iterator();

        }

    }

    public UpdateTablePanelImpl() {

        this.bookmarks = ToolsLocator.getBookmarksAndHistoryManager().getBookmarksGroup(BOOKMARKSANDHISTORY_NAME);

        this.history = ToolsLocator.getBookmarksAndHistoryManager().getHistoryGroup(BOOKMARKSANDHISTORY_NAME);

        this.initComponents();

    }

    private void initComponents() {

//        DataManager dataManager = DALLocator.getDataManager();

//        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        cfgActionsManager.addConfigurableActions(CONFIGURABLE_PANEL_ID, this, btnConfigurableActions);

        this.bookmarksController = ToolsSwingLocator.getToolsSwingManager().createBookmarksController(this.bookmarks, btnBookmarks);

        this.historyController = ToolsSwingLocator.getToolsSwingManager().createHistoryController(this.history, btnHistory);

        this.historyController.setFilter(null);

        ActionListener bookmarksAndHistoryListener = (ActionEvent e) -> {

                ActionEventWithCurrentValue<UpdateTableProcessParameters> event = (ActionEventWithCurrentValue<UpdateTableProcessParameters>) e;

                switch (event.getID()) {

                        case ID_GETVALUE:

                                event.setCurrentValue(fetch(null));

                                break;

                        case ID_SETVALUE:

                                put(event.getCurrentValue());

                                break;

                }

        };

        this.historyController.addActionListener(bookmarksAndHistoryListener);

        this.bookmarksController.addActionListener(bookmarksAndHistoryListener);

        this.rdoOptionsFulledit.setSelected(true);

        this.rdoOptionsFulledit.addActionListener((ActionEvent e) -> { doChangeSelectedEditMode(); });

        this.rdoOptionsPassthrought.setSelected(false);

        this.rdoOptionsPassthrought.addActionListener((ActionEvent e) -> { doChangeSelectedEditMode(); });

        this.rdoRecordsAll.setSelected(true);

        this.rdoRecordsEditeds.setSelected(false);

        this.rdoRecordsSelecteds.setSelected(false);

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

                null,

                this.lblStatusLabel, 

                this.lblStatusMessage, 

                this.pbStatus,

                this.btnCancelStatus,

                null

        );

        this.treeTableController = new StoresRepositoryController(this.treeTable);

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

            doChangeTable();

        });

        this.pickerTableFilter = expressionSwingManager.createExpressionPickerController(

                this.txtRecordFilter, 

                this.btnRecordFilter, 

                this.btnRecordFilterBookmarks, 

                this.btnRecordFilterHistory

        );

        this.pickerTableFilter.addChangeListener((ChangeEvent e) -> {

            doUpdatePreviewTable();

        });

        this.tableFields.setAutoCreateColumnsFromModel(false);

        this.tableFields.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        this.fieldsColumnModel = new DefaultTableColumnModel();

        TableColumn column;

        column = new TableColumn();

        column.setHeaderValue("Actualizar");

        column.setCellRenderer(null);

        column.setResizable(true);

        column.setModelIndex(0);

        this.fieldsColumnModel.addColumn(column);

        column = new TableColumn();

        column.setHeaderValue("Campo");

        column.setCellRenderer(null);

        column.setCellEditor(null);//new FeatureAttributeCellEditor());

        column.setResizable(true);

        column.setModelIndex(1);

        this.fieldsColumnModel.addColumn(column);

        column = new TableColumn();

        column.setHeaderValue("Expresion");

        column.setCellRenderer(null);

        column.setCellEditor(new ExpressionCellEditor());

        column.setResizable(true);

        column.setModelIndex(2);

        this.fieldsColumnModel.addColumn(column);

        this.tableFields.setColumnModel(this.fieldsColumnModel);

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

            doUpdatePreviewTable();

        });

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

            doConfigurePreviewColumns();

        });

        this.btnRecordsUpdatePreview.setEnabled(false);

        this.btnRecordsConfigurePreviewColumns.setVisible(false);

        this.tblRecordsPreview.setVisible(false);

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

            MyTableModel model = (MyTableModel) tableFields.getModel();

            for (MyTableModel.Row row : model) {

                row.update = false;    

            }

            model.fireTableDataChanged();

        });

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

            MyTableModel model = (MyTableModel) tableFields.getModel();

            for (MyTableModel.Row row : model) {

                row.update = true;    

            }

            model.fireTableDataChanged();

        });

        IntegerDocumentFilter.install(this.txtOptionsFinishAndRestarEditEach);

        toolsSwingManager.removeBorder(this.tblRecordsPreview);

        this.rdoRecordsAll.addActionListener((ActionEvent e) -> { doUpdateRecordsPreview(); });

        this.rdoRecordsEditeds.addActionListener((ActionEvent e) -> { doUpdateRecordsPreview(); });

        this.rdoRecordsSelecteds.addActionListener((ActionEvent e) -> { doUpdateRecordsPreview(); });

        SwingUtilities.invokeLater(() -> {

            this.lblStatusLabel.setText("");

            this.lblStatusMessage.setText("");

            this.status.setVisible(false);

        });

        ToolsSwingUtils.ensureRowsCols(this, 20, 80, 24, 100);

    }

    private void doUpdateRecordsPreview() {

        if( this.table == null ) {

            this.tblRecordsPreview.setVisible(false);

            this.btnRecordsConfigurePreviewColumns.setVisible(false);

            this.btnRecordsUpdatePreview.setVisible(false);

            return;

        }

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        SimpleFeaturesTableModel model = null;

        if( this.rdoRecordsAll.isSelected() ) {

            model = dataSwingManager.createSimpleFeaturesTableModel(table, this.pickerTableFilter.get());

        } else if( this.rdoRecordsEditeds.isSelected() ) {

            model = dataSwingManager.createSimpleEditedFeaturesTableModel(table, this.pickerTableFilter.get());

        } else if( this.rdoRecordsSelecteds.isSelected() ) {

            model = dataSwingManager.createSimpleSelectedFeaturesTableModel(table, this.pickerTableFilter.get());

        } else {

            // FIXME

        }

        model.setCellRenderers(tblRecordsPreview);

        this.tblRecordsPreview.setModel(model);

        this.tblRecordsPreview.setVisible(true);

        this.btnRecordsConfigurePreviewColumns.setVisible(false);

        this.btnRecordsUpdatePreview.setVisible(false);

        this.btnRecordsUpdatePreview.setEnabled(true);

    }

    private void doChangeTable() {

        this.table = this.treeTableController.getSelectedFeatureStore();

        if( this.table==null ) {

            return;

        }

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        dataSwingManager.configureExpressionBuilder(pickerTableFilter.getConfig(), table);

        this.tableFields.setModel(new MyTableModel());

        doUpdateRecordsPreview();

        FeatureStoreProviderFactory providerFactory = (FeatureStoreProviderFactory) this.getTable().getProviderFactory();

        switch( providerFactory.supportPassthroughMode() ) {

            case DataStoreProviderFactory.NO:

                this.rdoOptionsPassthrought.setSelected(false);

                this.rdoOptionsFulledit.setSelected(true);

                break;

            case DataStoreProviderFactory.YES:

            case DataStoreProviderFactory.UNKNOWN:

                if( !this.rdoOptionsPassthrought.isSelected() ) {

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    int n = dialogs.confirmDialog(

                            "La tabla seleccionada soporta el modo de paso-a-traves que es mas optimo que el actualmente seleccionado." +

                                    "\n" +

                                    "? Desea pasar a usar el modo de paso-a-traves ?",

                            "Update table",

                            JOptionPane.YES_NO_OPTION,

                            JOptionPane.QUESTION_MESSAGE,

                            "Desea pasar a usar el modo de paso-a-traves"

                    );

                    if( n==JOptionPane.YES_OPTION ) {

                        this.rdoOptionsPassthrought.setSelected(true);

                        this.rdoOptionsFulledit.setSelected(false);

                        this.doChangeSelectedEditMode();

                    }

                }

                break;

        }

    }

    private void doUpdatePreviewTable() {

        DataSwingManager manager = DALSwingLocator.getDataSwingManager();

        FeatureType ftype = this.table.getDefaultFeatureTypeQuietly();

        SimpleFeaturesTableModel model = manager.createSimpleFeaturesTableModel(

            ftype, 

            this.previewColumns, 

            this.table.getFeatures(this.pickerTableFilter.get())

        );

        this.tblRecordsPreview.setModel(model);

        this.btnRecordsConfigurePreviewColumns.setVisible(true);

        this.tblRecordsPreview.setVisible(true);

        if( this.previewColumns==null ) {

            this.previewColumns = model.getColumnNames();

        }

    }

    private void doConfigurePreviewColumns() {

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

        I18nManager i18n = ToolsLocator.getI18nManager();

        FeatureType ftype = this.table.getDefaultFeatureTypeQuietly();

        FeatureAttributesSelectionPanel panelSelectColumns = DALSwingLocator.getManager().createFeatureAttributeSelectionPanel();

        panelSelectColumns.allowCalculatedAttributes(false);

        panelSelectColumns.setFeatureType(ftype);

        panelSelectColumns.setSelectedNames(this.previewColumns);

        final Dialog dialog = winmanager.createDialog(

                panelSelectColumns.asJComponent(),

                i18n.getTranslation("_Select_the_columns_to_display"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

                if (dialog.getAction() == WindowManager_v2.BUTTONS_OK) {

                    this.previewColumns = panelSelectColumns.getSelectedNames();

                    doUpdatePreviewTable();

                }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    public FeatureStore getTable() {

        return this.table;

    }

    public Expression getTableFilter() {

        return this.pickerTableFilter.get();

    }

    public SimpleTaskStatus getStatus() {

        if( this.taskStatus == null ) {

            this.taskStatus = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("Copy table");

            this.status.bind(this.taskStatus);

        }

        this.status.setVisible(true);

        return this.taskStatus;

    }

    public void put(UpdateTableProcessParameters params) {

        this.table = null;

        switch(params.getEditMode()) {

            case FeatureStore.MODE_FULLEDIT:

            default:

                this.rdoOptionsFulledit.setSelected(true);

                this.rdoOptionsPassthrought.setSelected(false);

                break;

            case FeatureStore.MODE_PASS_THROUGH:

                this.rdoOptionsFulledit.setSelected(false);

                this.rdoOptionsPassthrought.setSelected(true);

                break;

        }

        this.chkOptionsBeginEditIfNeed.setSelected(params.isBeginEditIfNeed());

        this.chkOptionsFinishAndRestarEditEach.setSelected(params.isFinishAndRestarEdit());

        this.chkOptionsNotifyUserIfNeedBeginEditing.setSelected(params.isNotifyUserIfNeedBeginEditing());

        this.chkOptionsFinishEditAfterTerminate.setSelected(params.isFinishEditAfterTerminate());

        IntegerDocumentFilter.setValue(txtOptionsFinishAndRestarEditEach, params.getFinishAndRestarEditEach());

        switch(params.getRowsToProcess()) {

            case BATCHUPDATE_PROCESS_SELECTION:

                this.rdoRecordsSelecteds.setSelected(true);

                this.rdoRecordsEditeds.setSelected(false);

                this.rdoRecordsAll.setSelected(false);

                break;

            case BATCHUPDATE_PROCESS_EDITEDS:

                this.rdoRecordsSelecteds.setSelected(false);

                this.rdoRecordsEditeds.setSelected(true);

                this.rdoRecordsAll.setSelected(false);

                break;

            case BATCHUPDATE_PROCESS_ALL:

                this.rdoRecordsSelecteds.setSelected(false);

                this.rdoRecordsEditeds.setSelected(false);

                this.rdoRecordsAll.setSelected(true);

                break;

        }

        this.table = params.getStore();

        MyTableModel fieldsModel = new MyTableModel();

        this.tableFields.setModel(fieldsModel);

        for (MyTableModel.Row row : fieldsModel.rows) {

            ProcessFieldParameters paramfield = params.get(row.attrname);

            row.expression = paramfield.getExpression().getPhrase();

            row.update = paramfield.isUpdate();

        }

        fieldsModel.fireTableDataChanged();

    }

    public UpdateTableProcessParameters fetch(UpdateTableProcessParameters params) {

        if( params == null ) {

            params = new UpdateTableProcessParametersImpl();

        }

        params.setStore(table);

        if( this.rdoRecordsSelecteds.isSelected() ) {

            params.setRowsToProcess(BATCHUPDATE_PROCESS_SELECTION);

        }

        if( this.rdoRecordsEditeds.isSelected() ) {

            params.setRowsToProcess(BATCHUPDATE_PROCESS_EDITEDS);

        }

        if( this.rdoRecordsAll.isSelected() ) {

            params.setRowsToProcess(BATCHUPDATE_PROCESS_ALL);

        }

        MyTableModel model = (MyTableModel) this.tableFields.getModel();

        for (MyTableModel.Row row : model) {

            Expression exp = null;

            if( StringUtils.isNotBlank(row.expression)) {

                exp = ExpressionUtils.createExpression(row.expression);

            }

            params.add(row.attrname, row.update, exp);

        }    

        if( this.rdoOptionsFulledit.isSelected() ) {

            params.setEditMode(FeatureStore.MODE_FULLEDIT);

        } else {

            params.setEditMode(FeatureStore.MODE_PASS_THROUGH);

        }

        params.setBeginEditIfNeed(this.chkOptionsBeginEditIfNeed.isSelected());

        params.setFinishAndRestarEdit(this.chkOptionsFinishAndRestarEditEach.isSelected());

        params.setNotifyUserIfNeedBeginEditing(this.chkOptionsNotifyUserIfNeedBeginEditing.isSelected());

        params.setFinishEditAfterTerminate(this.chkOptionsFinishEditAfterTerminate.isSelected());

        params.setFinishAndRestarEditEach(IntegerDocumentFilter.getValue(txtOptionsFinishAndRestarEditEach));

        return params;

    }

    public void postProcess() {

        if( !SwingUtilities.isEventDispatchThread() ) {

            SwingUtilities.invokeLater(this::postProcess);

            return;

        }

        // TODO

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

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

        if (theme.exists(name)) {

            return theme.get(name);

        }

        return null;

    }    

    private void doChangeSelectedEditMode() {

        if( this.rdoOptionsPassthrought.isSelected() ) {

            this.chkOptionsBeginEditIfNeed.setEnabled(false);

            this.chkOptionsFinishAndRestarEditEach.setEnabled(false);

            this.chkOptionsFinishEditAfterTerminate.setEnabled(false);

            this.chkOptionsNotifyUserIfNeedBeginEditing.setEnabled(false);

            this.txtOptionsFinishAndRestarEditEach.setEnabled(false);

            this.rdoOptionsFulledit.setSelected(false);

        }

        if( this.rdoOptionsFulledit.isSelected() ) {

            this.chkOptionsBeginEditIfNeed.setEnabled(true);

            this.chkOptionsFinishAndRestarEditEach.setEnabled(true);

            this.chkOptionsFinishEditAfterTerminate.setEnabled(true);

            this.chkOptionsNotifyUserIfNeedBeginEditing.setEnabled(true);

            this.txtOptionsFinishAndRestarEditEach.setEnabled(true);

        }

    }

}