Application: gvSIG desktop

package org.gvsig.export.swing.impl.panels;

import java.awt.Component;

import java.awt.Font;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.awt.event.MouseEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import java.util.Timer;

import java.util.TimerTask;

import javax.swing.DefaultCellEditor;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

import javax.swing.text.JTextComponent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportAttributes.ExportAttribute;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.swing.JExportProcessPanel;

import org.gvsig.export.swing.spi.ExportPanel;

import org.gvsig.export.swing.spi.ExportPanelValidationException;

import org.gvsig.export.swing.spi.ExportPanelsManager;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.namestranslator.NamesTranslator;

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

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

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

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

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

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SelectAttributesPanel

        extends SelectAttributesPanelView

        implements ExportPanel {

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

    private static final int COLUMN_FIELD_EXPORT = 0;

    private static final int COLUMN_FIELD_TYPE = 1;

    private static final int COLUMN_FIELD_SIZE = 2;

    private static final int COLUMN_FIELD_ORIGIN = 3;

    private static final int COLUMN_FIELD_CALCULATED = 4;

    private static final int COLUMN_FIELD_NAME = 5;

    private static final int COLUMN_FIELD_NEW_NAME = 6;

    private static final int COLUMN_FIELD_COUNT = 7;

    private static final int ORIGIN_REAL = 0;

    private static final int ORIGIN_QUERY_CALCULATED = 1;

    private static final int ORIGIN_TABLE_CALCULATED = 2;

    private MessageBarController messageController;

    private static class AttributesTableModel

            extends AbstractTableModel

            implements TableModel {

        final private ExportAttributes attributes;

        private final String[] columnNames = new String[COLUMN_FIELD_COUNT];

        private final Class[] columnClases = new Class[COLUMN_FIELD_COUNT];

        private final String[] columnToolTips = new String[COLUMN_FIELD_COUNT];

        private final DataTypesManager dataManager;

        private final SelectAttributesPanel panel;

        public AttributesTableModel(ExportAttributes attributes, SelectAttributesPanel panel) {

            this.panel = panel;

            this.attributes = attributes;

            this.dataManager = ToolsLocator.getDataTypesManager();

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            columnNames[COLUMN_FIELD_NAME] = i18nManager.getTranslation("_name");

            columnNames[COLUMN_FIELD_NEW_NAME] = i18nManager.getTranslation("_New_name");

            columnNames[COLUMN_FIELD_ORIGIN] = i18nManager.getTranslation("_Origin");

            columnNames[COLUMN_FIELD_TYPE] = i18nManager.getTranslation("_type");

            columnNames[COLUMN_FIELD_SIZE] = i18nManager.getTranslation("_Size");

            columnNames[COLUMN_FIELD_CALCULATED] = i18nManager.getTranslation("_Virtual");

            columnNames[COLUMN_FIELD_EXPORT] = "";

            columnClases[COLUMN_FIELD_NAME] = String.class;

            columnClases[COLUMN_FIELD_NEW_NAME] = String.class;

            columnClases[COLUMN_FIELD_ORIGIN] = String.class;

            columnClases[COLUMN_FIELD_TYPE] = String.class;

            columnClases[COLUMN_FIELD_SIZE] = Integer.class;

            columnClases[COLUMN_FIELD_EXPORT] = Boolean.class;

            columnClases[COLUMN_FIELD_CALCULATED] = Boolean.class;

            columnToolTips[COLUMN_FIELD_NAME] = i18nManager.getTranslation("_Actual_field_name");

            columnToolTips[COLUMN_FIELD_NEW_NAME] = i18nManager.getTranslation("_New_field_name_in_the_export");

            columnToolTips[COLUMN_FIELD_ORIGIN] = i18nManager.getTranslation("_Origin");

            columnToolTips[COLUMN_FIELD_TYPE] = i18nManager.getTranslation("_Attribute_descriptor_type");

            columnToolTips[COLUMN_FIELD_SIZE] = i18nManager.getTranslation("_Field_size");

            columnToolTips[COLUMN_FIELD_CALCULATED] = i18nManager.getTranslation("_Export_attribute_as_an_expression_or_as_a_real_field");

            columnToolTips[COLUMN_FIELD_EXPORT] = i18nManager.getTranslation("_Select_if_field_has_to_be_exported");

        }

        public String getColumnToolTip(int column) {

            return columnToolTips[column];

        }

        @Override

        public int getRowCount() {

            return this.attributes.size();

        }

        @Override

        public int getColumnCount() {

            return COLUMN_FIELD_COUNT;

        }

        @Override

        public String getColumnName(int columnIndex) {

            return this.columnNames[columnIndex];

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            return this.columnClases[columnIndex];

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            switch (columnIndex) {

                case COLUMN_FIELD_NAME:

                    return false;

                case COLUMN_FIELD_ORIGIN:

                    return false;

                case COLUMN_FIELD_CALCULATED: {

                    ExportAttribute attr = this.attributes.get(rowIndex);

                    if (!attr.getDescriptor().isComputed()) {

                        return false;

                    }

                    DataType dataType = attr.getDescriptor().getDataType();

                    if( dataType.getType() == DataTypes.GEOMETRY ) {

                        return true;

                    }

                    if (dataType.isContainer()

                            || dataType.isObject()

                            || dataType.isDynObject()) {

                        return false;

                    }

                    return true;

                }

                default:

                    return true;

            }

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            ExportAttribute attr = this.attributes.get(rowIndex);

            switch (columnIndex) {

                case COLUMN_FIELD_NAME:

                    return attr.getName();

                case COLUMN_FIELD_NEW_NAME:

                    return attr.getNewName();

                case COLUMN_FIELD_ORIGIN:

                    if (attr.getDescriptor().isComputed()) {

                        if (attr.isFromQuery()){

                            return ORIGIN_QUERY_CALCULATED;

                        } else {

                            return ORIGIN_TABLE_CALCULATED;

                        }

                    } else {

                        return ORIGIN_REAL;

                    }

                case COLUMN_FIELD_TYPE:

                    try {

                        return dataManager.getTypeName(attr.getNewDataType());

                    } catch (Exception ex) {

                        return dataManager.getTypeName(attr.getDataType());

                    }

                case COLUMN_FIELD_SIZE:

                    return attr.getSize();

                case COLUMN_FIELD_EXPORT:

                    return attr.isExported();

                case COLUMN_FIELD_CALCULATED:

                    return attr.isComputed();

                default:

                    return null;

            }

        }

        @Override

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

            ExportAttribute attr = this.attributes.get(rowIndex);

            switch (columnIndex) {

                case COLUMN_FIELD_NAME:

                    break;

                case COLUMN_FIELD_NEW_NAME:

                    int indexChanged = attr.setNewName(Objects.toString(aValue, attr.getName()));

                    NamesTranslator translator = this.attributes.getNamesTranslator();

                    I18nManager i18 = ToolsLocator.getI18nManager();

                    if (!StringUtils.equalsIgnoreCase(Objects.toString(aValue, attr.getName()),

                            translator.getTranslation(attr.getName())))  {

                        StringBuilder changedLog = new StringBuilder();

                        changedLog.append("'");

                        changedLog.append(Objects.toString(aValue, attr.getName()));

                        changedLog.append("' ");

                        changedLog.append(i18.getTranslation("_field_name_has_been_fixed_to"));

                        changedLog.append(" '");

                        changedLog.append(translator.getTranslation(attr.getName()));

                        changedLog.append("'");

                        panel.setMessage(changedLog.toString());

                    }

                    if (indexChanged != -1) {

                        String fieldSource = translator.getSource(indexChanged);

                        String fieldTarget = translator.getTranslation(indexChanged);

                        StringBuilder changedLog = new StringBuilder();

                        changedLog.append("'");

                        changedLog.append(fieldSource);

                        changedLog.append("' ");

                        changedLog.append(i18.getTranslation("_has_been_changed_to_avoid_duplicates_for"));

                        changedLog.append(" '");

                        changedLog.append(fieldTarget);

                        changedLog.append("'");

                        panel.setMessage(changedLog.toString());

                    }

                    break;

                case COLUMN_FIELD_TYPE:

                    attr.setNewType(dataManager.getType(Objects.toString(aValue)));

                    break;

                case COLUMN_FIELD_SIZE:

                    try {

                    attr.setSize(Integer.parseInt(Objects.toString(aValue)));

                } catch (Exception ex) {

                    LOGGER.warn("Not been able to set size value of attribute " + attr.getName() + " (" + Objects.toString(aValue) + ").", ex);

                }

                break;

                case COLUMN_FIELD_EXPORT:

                    try {

                    attr.setExported((boolean) dataManager.get(DataTypes.BOOLEAN).coerce(aValue));

                } catch (Exception ex) {

                    LOGGER.warn("Not been able to set exported value of attribute " + attr.getName() + " (" + Objects.toString(aValue) + ").", ex);

                }

                break;

                case COLUMN_FIELD_CALCULATED:

                    try {

                    attr.setComputed((boolean) dataManager.get(DataTypes.BOOLEAN).coerce(aValue));

                } catch (Exception ex) {

                    LOGGER.warn("Not been able to set calculated value of attribute " + attr.getName() + " (" + Objects.toString(aValue) + ").", ex);

                }

                break;

                default:

                    break;

            }

            this.fireTableCellUpdated(rowIndex, columnIndex);

        }

    }

    private static class TableFilterController {

        private final JTable jtable;

        private final JTextComponent jtext;

        private final JButton btnFilter;

        private final int filterColumn;

        private FilteredTableModel tableModel;

        public TableFilterController(JTable jtable, JTextComponent jtext, JButton btnFilter, int filterColumn) {

            this.jtable = jtable;

            this.filterColumn = filterColumn;

            this.btnFilter = btnFilter;

            this.jtext = jtext;

            this.tableModel = null;

            ToolsSwingLocator.getToolsSwingManager().setDefaultPopupMenu(jtext);

            ToolsSwingLocator.getToolsSwingManager().addClearButton(jtext, new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    if (tableModel != null) {

                        tableModel.setFilter(null);

                        jtext.setText("");

                    }

                }

            });

            this.jtext.addKeyListener(new KeyAdapter() {

                @Override

                public void keyPressed(KeyEvent e) {

                    if (e.getKeyChar() == '\n') {

                        if (tableModel != null) {

                            tableModel.setFilter(jtext.getText());

                        }

                    }

                }

            });

            this.btnFilter.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    if (tableModel != null) {

                        tableModel.setFilter(jtext.getText());

                    }

                }

            });

        }

        public void setModel(TableModel tableModel) {

            this.tableModel = ToolsSwingLocator.getToolsSwingManager().createFilteredTableModel(

                    tableModel,

                    this.filterColumn

            );

            this.jtable.setModel(this.tableModel);

        }

    }

    private class DataTypeCellRenderer

            extends JLabel

            implements TableCellRenderer {

        public DataTypeCellRenderer() {

        }

        @Override

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

            if (value != null) {

                String name = (String) table.getModel().getValueAt(row, COLUMN_FIELD_NAME);

                this.setText(value.toString());

                Font f = this.getFont();

                if (isOriginalType(row, value.toString())) {

                    this.setFont(f.deriveFont(f.getStyle() & ~Font.BOLD));

                } else {

                    this.setFont(f.deriveFont(f.getStyle() | Font.BOLD));

                }

            } else {

                this.setText("");

            }

            return this;

        }

    }

    private class OriginCellRenderer

            extends JLabel

            implements TableCellRenderer {

        public OriginCellRenderer() {

        }

        @Override

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

            if (column == COLUMN_FIELD_ORIGIN) {

                int origin = (int) table.getModel().getValueAt(row, COLUMN_FIELD_ORIGIN);

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

                I18nManager i18Manager = ToolsLocator.getI18nManager();

                this.setHorizontalAlignment(JLabel.CENTER);

                switch (origin) {

                    case ORIGIN_QUERY_CALCULATED:

                        this.setToolTipText(i18Manager.getTranslation("_Query_calculated_field"));

                        this.setIcon((iconManager.get("featurestore-query-calculated-column")));

                        break;

                    case ORIGIN_TABLE_CALCULATED:

                        this.setToolTipText(i18Manager.getTranslation("_Table_calculated_field"));

                        this.setIcon((iconManager.get("featurestore-calculated-column")));

                        break;

                    case ORIGIN_REAL:

                        this.setToolTipText(i18Manager.getTranslation("_Real_field"));

                        this.setIcon((iconManager.get("featurestore-column")));

                        break;

                    default:

                        this.setText(value.toString());

                        break;

                }

                return this;

            }

            return this;

        }

    }

    private class DataTypeCellEditor extends DefaultCellEditor {

        private int currentRow = -1;

        private class DataTypeListCellRenderer extends DefaultListCellRenderer {

            @Override

            public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

                JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

                if (value != null) {

                    label.setText(value.toString());

                    Font f = label.getFont();

                    if (isOriginalType(currentRow, value.toString())) {

                        label.setFont(f.deriveFont(f.getStyle() | Font.BOLD));

                    } else {

                        label.setFont(f.deriveFont(f.getStyle() & ~Font.BOLD));

                    }

                }

                return label;

            }

        }

        public DataTypeCellEditor() {

            super(new JComboBox());

            JComboBox combo = (JComboBox) this.getComponent();

            combo.setRenderer(new DataTypeListCellRenderer());

            combo.setModel(this.getDataTypeComboModel());

        }

        @Override

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

            this.currentRow = row;

            JComboBox combo = (JComboBox) super.getTableCellEditorComponent(table, value, isSelected, row, column);

            ListElement.setSelected(combo, value);

            return combo;

        }

        private DefaultComboBoxModel getDataTypeComboModel() {

            DataTypesManager dataManager = ToolsLocator.getDataTypesManager();

            List<ListElement<Integer>> fieldTypes = new ArrayList<>();

            Iterator<DataType> it = dataManager.iterator();

            while (it.hasNext()) {

                DataType dataType = it.next();

                fieldTypes.add(new ListElement<>(dataType.getName(), dataType.getType()));

            }

            fieldTypes.sort(new Comparator<ListElement<Integer>>() {

                @Override

                public int compare(ListElement<Integer> o1, ListElement<Integer> o2) {

                    return o1.toString().compareTo(o2.toString());

                }

            });

            DefaultComboBoxModel<ListElement<Integer>> model = new DefaultComboBoxModel<>();

            for (ListElement<Integer> element : fieldTypes) {

                model.addElement(element);

            }

            return model;

        }

    }

    private final ExportParameters parameters;

    private final JExportProcessPanel processPanel;

//    private Map<String, String> fieldAttributeTypes;

//    private FilteredTableModel filteredTableModel;

    private TableModel tableModel;

    private TableFilterController tableFilterController;

    private FeatureType targetFeatureType;

    public SelectAttributesPanel(

            JExportProcessPanel processPanel,

            ExportParameters parameters

    ) {

        this.processPanel = processPanel;

        this.parameters = parameters;

        this.parameters.getExportAttributes().setActive(true);

        this.initComponents();

    }

    @Override

    public String getIdPanel() {

        return ExportPanelsManager.PANEL_ATTRIBUTES_SELECTION;

    }

    @Override

    public String getTitlePanel() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation("_Attribute_Selection");

    }

    @Override

    public boolean validatePanel() throws ExportPanelValidationException {

        ExportAttributes attributes = this.parameters.getExportAttributes();

        FeatureType theTargetFeatureType = attributes.getTargetFeatureType();

        boolean areComputed = false;

        for (FeatureAttributeDescriptor featureAttributeDescriptor : theTargetFeatureType) {

            if(featureAttributeDescriptor.isComputed()){

                areComputed = true;

                break;

            }

        }

        if(areComputed){

            I18nManager i18n = ToolsLocator.getI18nManager();

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            int r = dialogs.confirmDialog(

                    i18n.getTranslation("_Virtual_attribute_have_been_selected_it_is_very_possible_that_the_result_can_only_be_opened_by_gvSIG")+"\n"+

                            i18n.getTranslation("_do_you_wish_to_continue"), //message

                    i18n.getTranslation("_Attributes_selection"), //title

                    JOptionPane.YES_NO_OPTION, //OptionType

                    JOptionPane.WARNING_MESSAGE, //messageType

                    "_export_wizard_virtual_attributes_selection" //msgid

            );

            if(r != JOptionPane.YES_OPTION){

                return false;

            }

        }

        return true;

    }

    @Override

    public void enterPanel() {

        this.fillTableWithAttributes();

    }

    @Override

    public void previousPanel() {

        this.fillTableWithAttributes();

    }

    @Override

    public void nextPanel() {

//        ExportAttributes attributes = this.parameters.getExportAttributes();

//        FeatureType theTargetFeatureType = attributes.getTargetFeatureType();

//        boolean areComputed = false;

//        for (FeatureAttributeDescriptor featureAttributeDescriptor : theTargetFeatureType) {

//            if(featureAttributeDescriptor.isComputed()){

//                areComputed = true;

//                break;

//            }

//        }

//        if(areComputed){

//            I18nManager i18n = ToolsLocator.getI18nManager();

//            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

//            dialogs.confirmDialog(

//                    i18n.getTranslation("_There_are_selected_virtual_attributes_it_is_very_possible_that_the_result_can_only_be_opened_by_gvSIG")+"\n"+

//                            i18n.getTranslation("_do_you_wish_to_continue"), //message

//                    i18n.getTranslation("_Attributes_selection"), //title

//                    JOptionPane.YES_NO_OPTION, //OptionType

//                    JOptionPane.WARNING_MESSAGE, //messageType

//                    "_virtual_attributes_selection" //msgid

//            );

//            

//        }

        //get params are in the validate method

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    private boolean isOriginalType(int row, String type) {

        try {

            if (this.targetFeatureType == null) {

                return true;

            }

            TableModel model = this.tblAttributes.getModel();

            String name = (String) model.getValueAt(row, COLUMN_FIELD_NAME);

            FeatureAttributeDescriptor attr = this.targetFeatureType.getAttributeDescriptor(name);

            if (attr == null) {

                return true;

            }

            return StringUtils.equalsIgnoreCase(type, attr.getDataTypeName());

        } catch (Exception ex) {

            return true;

        }

    }

    private ExportAttributes getExportAttributes() {

        ExportAttributes attributes = this.parameters.getExportAttributes();

        return attributes;

    }

    private void fillTableWithAttributes() {

        ExportAttributes attributes = this.getExportAttributes();

        if (this.targetFeatureType == null) {

            this.targetFeatureType = this.getExportAttributes().getTargetFeatureType();

        }

        this.tableModel = new AttributesTableModel(attributes, this);

        this.tblAttributes.setModel(this.tableModel);

        this.tableFilterController.setModel(this.tableModel);

        TableColumnModel columnModel = this.tblAttributes.getColumnModel();

        columnModel.getColumn(COLUMN_FIELD_ORIGIN).setCellRenderer(new OriginCellRenderer());

        columnModel.getColumn(COLUMN_FIELD_TYPE).setCellEditor(new DataTypeCellEditor());

        columnModel.getColumn(COLUMN_FIELD_TYPE).setCellRenderer(new DataTypeCellRenderer());

        columnModel.getColumn(COLUMN_FIELD_EXPORT).setPreferredWidth(new JCheckBox().getPreferredSize().width * 2);

        columnModel.getColumn(COLUMN_FIELD_TYPE).setPreferredWidth(new JLabel("XIntegerX").getPreferredSize().width);

        columnModel.getColumn(COLUMN_FIELD_SIZE).setPreferredWidth(new JLabel("00000").getPreferredSize().width);

        columnModel.getColumn(COLUMN_FIELD_ORIGIN).setPreferredWidth(new JLabel("000").getPreferredSize().width);

        columnModel.getColumn(COLUMN_FIELD_CALCULATED).setPreferredWidth(new JLabel("000").getPreferredSize().width);

    }

    private void initComponents() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        this.tblAttributes.getTableHeader().setToolTipText(

        i18n.getTranslation("_Select_in_the_check_box_wich_fields_wanted_to_be_exported_and_configure_its_attributes"));

        this.messageController = ToolsSwingLocator.getToolsSwingManager().createMessageBarController(lblMessage, 10000);

        this.tblAttributes.setAutoCreateRowSorter(true);

        this.tblAttributes.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);

        //this.lblHeader.setText(i18n.getTranslation("_Select_name_type_size_and_attributes_to_export"));

        this.lblHeader.setText("<HTML>"+i18n.getTranslation("_Check_wich_fields_you_want_to_export_and_configure_its_attributes") + ". " +

               i18n.getTranslation("_Select_the_name_of_the_new_field_size_and_type_that_each_field_will_have_in_the_export_result")+".</HTML>");

        this.tableFilterController = new TableFilterController(

                this.tblAttributes,

                this.txtFilter,

                this.btnFilter,

                COLUMN_FIELD_NAME

        );

        this.btnCheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doCheckAll();

            }

        });

        this.btnUncheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUncheckAll();

            }

        });

        this.translate();

    }

    private void doUncheckAll() {

        TableModel model = this.tblAttributes.getModel();

        for (int row = 0; row < model.getRowCount(); row++) {

            model.setValueAt(false, row, COLUMN_FIELD_EXPORT);

        }

    }

    private void doCheckAll() {

        TableModel model = this.tblAttributes.getModel();

        for (int row = 0; row < model.getRowCount(); row++) {

            model.setValueAt(true, row, COLUMN_FIELD_EXPORT);

        }

    }

    private void translate() {

        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();

        manager.translate(this.lblHeader);

    }

    @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(name + ".png");

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    }

    private void setMessage(String toString) {

        this.messageController.setText(toString);

    }

}