Application: gvSIG desktop

        extends DefaultSearchPanelView2

        implements FeatureStoreSearchPanel, SupportIsEnable, SupportIsVisible {

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

    static /* friend */ Integer useLabels = null;

    private BookmarksController bookmarksController;

    private HistoryController historyController;

    private FeatureQuery lastQuery;

    private Feature lastSelectedFeature;    

    private final PropertiesSupportHelper propertiesHelper;

    private TaskStatusController taskStatusController;

    public static class UseLabelsYesAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UseLabelsYesAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Use_labels"));

            this.putValue(ACTION_COMMAND_KEY, "UseLabelsYes");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Use_labels");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel.useLabels = USE_LABELS_YES;

        }

    }

    public static class UseLabelsNoAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UseLabelsNoAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Use_names"));

            this.putValue(ACTION_COMMAND_KEY, "UseLabelsNo");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Use_names");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel.useLabels = USE_LABELS_NO;

        }

    }

    public static class UseLabelsBothAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public UseLabelsBothAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Use_labels_and_names"));

            this.putValue(ACTION_COMMAND_KEY, "UseLabelsBoth");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Use_labels_and_names");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel.useLabels = USE_LABELS_BOTH;

        }

    }

    public static class SelectColumnsAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public SelectColumnsAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Select_columns_to_display"));

            this.putValue(ACTION_COMMAND_KEY, "SelectColumns");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Select_columns_to_display");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doSelectResultColumnNames();

        }

    }

    public static class CalculatedColumnsAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public CalculatedColumnsAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Calculated_columns"));

            this.putValue(ACTION_COMMAND_KEY, "CalculatedColumns");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Calculated_columns");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doCalculatedColumns();

        }

    }

    public static class GroupByAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public GroupByAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Group_by"));

            this.putValue(ACTION_COMMAND_KEY, "GroupBy");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Group_by");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doGroupBy();

        }

    }

    public static class OrderByAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public OrderByAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Order_by"));

            this.putValue(ACTION_COMMAND_KEY, "SelectOrderBy");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Order_by");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            DefaultSearchPanel panel = (DefaultSearchPanel) ae.getSource();

            panel.doOrderBy();

        }

    }

    private class TablePopupMenu extends JPopupMenu {

            public final JTable table;

            @SuppressWarnings("OverridableMethodCallInConstructor")

            public TablePopupMenu(JTable inputTable) {

                this.table = inputTable;

                I18nManager i18n = ToolsLocator.getI18nManager();

                JMenuItem copyRowsActionMenu = new JMenuItem(i18n.getTranslation("_Copy_rows"));

                copyRowsActionMenu.addActionListener((ActionEvent e) -> {

                    doCopyRows(table);

                });

                this.add(copyRowsActionMenu);

            }

        }

    private class ActionButtons {

        private final DALActionFactory factory;

        private final Action action;

        private final JButton button;

        public ActionButtons(DALActionFactory factory, Action action, JButton button) {

            this.factory = factory;

            this.action = action;

            this.button = button;

        }

    }

    public static class SearchActionContext extends AbstractDALActionContext {

        private final DefaultSearchPanel panel;

        public SearchActionContext(DefaultSearchPanel panel) {

            super(FeatureStoreSearchPanel.ACTION_CONTEXT_NAME);

            this.panel = panel;

        }

        @Override

        public DataStore getStore() {

            if (this.panel.currentPostProcess == null || this.panel.tabResults.getSelectedIndex() == 0) {

                return this.panel.getStore();

            } else {

                return this.panel.postProcessStore;

            }

        }

        @Override

        public JComponent getActionButton(String actionName) {

            return this.panel.getActionButton(actionName);

        }

        @Override

        public int getSelectedsCount() {

            return this.panel.getSelectedFeatureCount();

        }

        @Override

        public Expression getFilterForSelecteds() {

            return this.panel.getFilterForSelectedFeature();

        }

        @Override

        public FeatureQuery getQuery() {

            if (this.panel.currentPostProcess == null || this.panel.tabResults.getSelectedIndex() == 0) {

                return this.panel.parameters.getQuery();

            } else {

                return this.panel.postProcessQuery;

            }

        }

    }

    private FeatureStore store;

    private final ActionListenerSupport acctionListeners;

    private final Map<String, ActionButtons> actions;

    private boolean showActions = true;

    private DefaultSearchParameters parameters;

    private List<SearchConditionPanel> conditionPanels;

    public static final int PANEL_SIMPLIFIED = 0;

    public static final int PANEL_ADVANCED = 1;

    private static final String BOOKMARKSANDHISTORY_NAME = "SearchPanel";

    private final Bookmarks<Object> bookmarks;

    private final History<Object> history;

    private boolean filterOnlyMode;

    private String currentPostProcess;

    private DynObject postProcessParams;

    private FeatureStore postProcessStore;

    private FeatureQuery postProcessQuery;

    private SimpleFeaturesTableModel resultModel;

    private SimpleFeaturesTableModel resultPostProcessModel;

    private boolean processing;

    private JComponent configurableActions;

    @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})

    public DefaultSearchPanel(FeatureStore store) {

        this.store = store;

        this.filterOnlyMode = false;

        DisposeUtils.bind(store);

        this.acctionListeners = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

        this.actions = new HashMap<>();

        this.parameters = new DefaultSearchParameters();

        FeatureQuery featureQuery = this.store.createFeatureQuery();

        featureQuery.retrievesAllAttributes();

        this.parameters.setQuery(featureQuery);

        this.currentPostProcess = null;

        this.postProcessParams = null;

        this.postProcessStore = null;

        this.postProcessQuery = null;

        this.processing = false;

        this.configurableActions = null;

        this.resultModel = null;

        this.resultPostProcessModel = null;

        this.propertiesHelper = new PropertiesSupportHelper();

        this.propertiesHelper.setProperty("SearchPanel", this);

        Search search = (Search) ToolsLocator.getComplementsManager().get(

                Search.COMPLEMENT_MANE, getFeatureType()

        );

        List<Search.OrderedAttribute> attributos = search.getOrderedAttributes(

                Search.BASIC_TYPES_FILTER,

                Search.STR_INT_LONG_LABEL_ORDER,

                12

        );

        for (Search.OrderedAttribute attrdesc : attributos) {

            this.parameters.getResultColumnNames().add(attrdesc.getDescriptor().getName());

        }

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

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

    }

    @Override

    public void dispose() {

        DisposeUtils.disposeQuietly(store);

        TableModel m = this.tblResults.getModel();

        if (m instanceof Disposable) {

            DisposeUtils.disposeQuietly((Disposable) m);

        }

        this.store = null;

        this.tblResults.setModel(new DefaultTableModel());

    }

    @Override

    public JComponent asJComponent() {

        if (this.conditionPanels == null) {

            this.initComponents();

        }

        return this;

    }

    private void addActions() {

        if (!this.showActions) {

            return;

        }

        this.pnlActions.removeAll();

        this.pnlActions.setLayout(new FlowLayout(FlowLayout.TRAILING, 8, 4));

        SearchActionContext actionContext = new SearchActionContext(this);

        Collection<DALActionFactory> factories = DALSwingLocator.getSwingManager().getStoreActions();

        for (DALActionFactory factory : factories) {

            if (!factory.isApplicable(actionContext)) {

                continue;

            }

            Action action = factory.createAction(actionContext);

            JButton button = new JButton(action);

            this.actions.put(factory.getName(), new ActionButtons(factory, action, button));

            button.setBorder(BorderFactory.createEmptyBorder());

            button.setBorderPainted(false);

            button.setFocusPainted(false);

            button.setContentAreaFilled(false);

            button.setCursor(new Cursor(Cursor.HAND_CURSOR));

            this.pnlActions.add(button);

        }

        this.pnlActions.revalidate();

        this.pnlActions.repaint();

    }

    @Override

    public void addActionListener(ActionListener listener) {

        this.acctionListeners.addActionListener(listener);

    }

    @Override

    public ActionListener[] getActionListeners() {

        return this.acctionListeners.getActionListeners();

    }

    @Override

    public void removeActionListener(ActionListener listener) {

        this.acctionListeners.removeActionListener(listener);

    }

    @Override

    public void removeAllActionListener() {

        this.acctionListeners.removeAllActionListener();

    }

    @Override

    public void fireActionEvent(ActionEvent event) {

        this.acctionListeners.fireActionEvent(event);

    }

    @Override

    public boolean hasActionListeners() {

        return this.acctionListeners.hasActionListeners();

    }

    private void initComponents() {

        this.conditionPanels = new ArrayList<>();

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.tabSearchMode);

        swingManager.translate(this.tabResults);

        swingManager.translate(this.btnSearch);

        swingManager.translate(this.btnClear);

        swingManager.translate(this.btnSearchPostProcess);

        swingManager.translate(this.lblExpressionDeBusqueda);

        swingManager.translate(this.btnAddAccumulatedFilter);

        swingManager.translate(this.btnRemoveAccumulatedFilter);

        swingManager.translate(this.btnViewAccumulatedFilter);

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        this.configurableActions = cfgActionsManager.getConfigurableActionsComponent(CONFIGURABLE_PANEL_ID, this);

        this.pnlCfgActions.setLayout(new BorderLayout(0, 0));

        this.pnlCfgActions.add(configurableActions, BorderLayout.CENTER);

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

                this.lblStatusTitle, 

                this.lblMsg, 

                this.pgbStatus);

        this.conditionPanels.add(

                new SearchConditionPanelSimplified(

                        parameters,

                        store,

                        btnAddAccumulatedFilter,

                        btnRemoveAccumulatedFilter,

                        btnViewAccumulatedFilter,

                        lblField1,

                        lblExtraFields1,

                        lblRelationalOperator1,

                        cboValue1,

                        lblNull1,

                        lblLogicalOperators1,

                        lblField2,

                        lblExtraFields2,

                        lblRelationalOperator2,

                        cboValue2,

                        lblNull2,

                        lblLogicalOperators2,

                        lblField3,

                        lblExtraFields3,

                        lblRelationalOperator3,

                        cboValue3,

                        lblNull3,

                        lblLogicalOperators3,

                        lblField4,

                        lblExtraFields4,

                        lblRelationalOperator4,

                        cboValue4,

                        lblNull4,

                        null

                )

        );

        SearchConditionPanelAdvanced advancedPanel = new SearchConditionPanelAdvanced(

                this.store,

                txtAdvancedExpression,

                btnAdvancedExpression,

                btnAdvancedExpressionHistory,

                btnAdvancedExpressionBookmarks

        );

        this.conditionPanels.add(advancedPanel);

        for (SearchConditionPanelFactory factory : DALSwingLocator.getManager().getSearchConditionPanels()) {

            String factoryName = "unknown";

            try {

                factoryName = factory.getName();

                if (factory.isApplicable(store)) {

                    SearchConditionPanel panel = factory.create(this);

                    this.conditionPanels.add(panel);

                    this.tabSearchMode.add(factory.getName(), panel.asJComponent());

                }

            } catch (Throwable th) {

                LOGGER.warn("Can't create search panel '" + factoryName + "'.");

            }

        }

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

            this.tabResults.setEnabledAt(1, false);

            search();

        });

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

            try {

                lastSelectedFeature = resultModel.getFeatureAt(tblResults.getSelectedRow());

            } catch(Throwable th ) {

                LOGGER.debug("Can't retrieve last selected feature.",th);

            }

            for (ActionButtons actionButton : actions.values()) {

                if (actionButton.action instanceof ListSelectionListener) {

                    ((ListSelectionListener) actionButton.action).valueChanged(e);

                }

            }

        });

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

            clear();

        });

        addActions();

        //swingManager.createTableColumnAdjuster(tblResults);

        //swingManager.createTableColumnAdjuster(tblSearchPostProcessResults);

        ToolsSwingUtils.ensureRowsCols(this, 20, 100, 30, 120);

        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<DefaultSearchParameters> b = (ActionEventWithCurrentValue<DefaultSearchParameters>) e;

            switch (b.getID()) {

                case ID_GETVALUE:

                    DefaultSearchParameters actualParams = (DefaultSearchParameters) fetch(null);

                    b.setCurrentValue(actualParams);

                    break;

                case ID_SETVALUE:

                    if (b.getCurrentValue() == null) {

                        return;

                    }

                    DefaultSearchParameters searchParams;

                    try {

                        searchParams = b.getCurrentValue().getCopy();

                    } catch (Exception ex) {

                        LOGGER.warn("Not been able to clone export parameters", ex);

                        return;

                    }

                    clear();

                    put(searchParams);

                    Thread th = new Thread(() -> {

                        doSearch(searchParams);

                    });

                    th.start();

                    break;

            }

        };

        this.historyController.addActionListener(bookmarksAndHistoryListener);

        this.bookmarksController.addActionListener(bookmarksAndHistoryListener);

        this.addComponentListener(new ComponentAdapter() {

            @Override

            public void componentHidden(ComponentEvent e) {

                dispose();

            }

        });

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

            try {

                doSelectSearchPostprocess();

            } catch (DataException ex) {

                LOGGER.warn("Can't select a Search Post Process", ex);

            }

        });

        this.tabResults.setEnabledAt(1, false);

        this.tblResults.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

        this.tblResults.addKeyListener(new KeyAdapter() {

            @Override

            public void keyPressed(KeyEvent e) {

                if( e.getKeyCode()==KeyEvent.VK_F4 ) {

                    doShowCellInDialog();

                }

            }

        });        

        this.tblResults.setComponentPopupMenu(new TablePopupMenu(this.tblResults));

        this.tblSearchPostProcessResults.setComponentPopupMenu(new TablePopupMenu(this.tblSearchPostProcessResults));

        //this.tblResults.add

        if (this.bookmarks.hasBookmark(this.store.getName())) {

            Bookmark<DefaultSearchParameters> initBookmark = this.bookmarks.get(this.store.getName());

            DefaultSearchParameters initSearchParams = initBookmark.getValue().getCopy();

            put(initSearchParams);

            Thread th = new Thread(() -> {

                doSearch(initSearchParams);

            });

            th.start();

            return;

        }

        this.tabResults.addChangeListener((ChangeEvent evt) -> {

            SwingUtilities.invokeLater(() -> {

                if(tabResults.getSelectedIndex()==0){

                    updateNumberElementsMsg(resultModel);

                }else{

                    updateNumberElementsMsg(resultPostProcessModel);

                }

            });

        });

        if( this.filterOnlyMode ) {

            this.btnSearchPostProcess.setVisible(false);

        }

        clear();

        search();

    }

    private void doShowCellInDialog() {

        int row = this.tblResults.getSelectedRow();

        if( row < 0 ) {

            return;

        }

        int col = this.tblResults.getSelectedColumn();

        if( col < 0 ) {

            return;

        }

        String s = Objects.toString(this.tblResults.getValueAt(row, col),null);

        if( StringUtils.isBlank(s) ) {

            return;

        }

        ToolsSwingLocator.getToolsSwingManager().showZoomDialog(

            this, 

            this.tblResults.getColumnName(col), 

            s,

            false

        );

    }

    @Override

    public FeatureType getFeatureType() {

        try {

            return store.getDefaultFeatureType();

        } catch (Exception ex) {

            throw new RuntimeException("Can't retrieve the feature type.", ex);

        }

    }

    @Override

    public void setEnabled(boolean enabled) {

        if(!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(() -> {setEnabled(enabled);});

            return;

        }

        if (this.conditionPanels == null) {

            this.initComponents();

        }

        for (SearchConditionPanel conditionPanel : conditionPanels) {

            conditionPanel.setEnabled(enabled);

        }

        this.btnClear.setEnabled(enabled);

        this.btnSearch.setEnabled(enabled);

        for (ActionButtons actionButton : actions.values()) {

            actionButton.action.setEnabled(enabled);

        }

        this.btnSearchPostProcess.setEnabled(enabled);

        //bookmarkController,historyController,configurableActions

    }

    @Override

    public void clear() {

        this.taskStatusController.setTitle("");

        if (this.conditionPanels == null) {

            return;

        }

        for (SearchConditionPanel conditionPanel : conditionPanels) {

            conditionPanel.clear();

        }

        FeatureQuery emptyQuery = this.store.createFeatureQuery();

        emptyQuery.retrievesAllAttributes();

        this.parameters.setQuery(emptyQuery);

        // Mantener las columnas visualizadas

        // Elimina las que no existen en el store como campos calculados que

        // pudieran existir en el fquery

        List<String> resultColumnNames = this.parameters.getResultColumnNames();

        ArrayList<String> toDeleteAlreadyDontExist = new ArrayList<>();

        for (String resultColumnName : resultColumnNames) {

            try {

                FeatureAttributeDescriptor attr = this.store.getDefaultFeatureType().getAttributeDescriptor(resultColumnName);

                if (attr == null) {

                    toDeleteAlreadyDontExist.add(resultColumnName);

                }

            } catch (DataException ex) {

            }

        }

        resultColumnNames.removeAll(toDeleteAlreadyDontExist);

        resetTable();

    }

    @Override

    public FeatureQuery getLastQuery() {

        return this.lastQuery;

    }

    public boolean isValid(StringBuilder message) {

        int searchMode = this.tabSearchMode.getSelectedIndex();

        SearchConditionPanel panel = this.conditionPanels.get(searchMode);

        boolean valid = panel.isValid(message);

        return valid;

    }

    @Override

    public void search() {

        StringBuilder message = new StringBuilder();

        if (!this.isValid(message)) {

            ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogManager.messageDialog(

                    "_The_specified_search_condition_is_not_valid",

                    "_Search",

                    JOptionPane.WARNING_MESSAGE

            );

            return;

        }

        lblMsg.setText(ToolsLocator.getI18nManager().getTranslation("_Searching")+"...");

        setEnabled(false);

        Thread th = new Thread(() -> {

        try {

        });

        th.start();

    }

    private void doSearch(SearchParameters searchParams)  {

            final MutableObject model = new MutableObject(null);       

            final MutableLong rowCount=new MutableLong();

			Cursor savedCursor = this.getCursor();

		    SimpleTaskStatus status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("");

			status.setAutoremove(true);

			status.add();

			this.taskStatusController.bind(status);

            try {

				status.setTitle(ToolsLocator.getI18nManager().getTranslation("_Processing_search"));

				SwingUtilities.invokeLater(() -> {this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));});

                final List<Feature> features;

                 FeatureQuery myQuery;

                this.tabResults.setSelectedIndex(0);

                List<String> resultColumnNames = searchParams.getResultColumnNames();

                myQuery = searchParams.getQuery().getCopy();

                features = store.getFeatures(myQuery, 50);

                FacadeOfAFeaturePagingHelper facade = (FacadeOfAFeaturePagingHelper) features;

                FeatureType ftype = facade.getFeaturePagingHelper().getFeatureSet().getDefaultFeatureType();

                // al modelo le pasamos el ftype de esas features

                SimpleFeaturesTableModel tableModel = new SimpleFeaturesTableModelImpl(

                        ftype,

                        resultColumnNames,

                        features

                );

                model.setValue(tableModel);

                rowCount.setValue(tableModel.getRowCount());

            } catch (Exception ex) {

                LOGGER.warn("Search not able to be executed. Can't get features or create table model", ex);

                status.setTitle(ToolsLocator.getI18nManager().getTranslation("_Errors_getting_new_feature_set") + "...");

				status.abort();

                resetTable();

            } finally {

                SwingUtilities.invokeLater(() -> {

                    I18nManager i18n = ToolsLocator.getI18nManager();

                    try {

                        TableModel oldmodel = tblResults.getModel();

                        resultModel = (SimpleFeaturesTableModel) model.getValue();

                        tblResults.setModel(resultModel);

                        resultModel.setCellRenderers(tblResults,getCustomRenderers(searchParams));

                        if (oldmodel instanceof SimpleFeaturesTableModelImpl) {

                            ((SimpleFeaturesTableModelImpl) oldmodel).dispose();

                        }

                        if (resultModel.hasErrors()) {

                            status.setTitle(i18n.getTranslation("_Errors_occurred_during_search"));

                        } else {

                            status.setTitle(String.format("%d " + i18n.getTranslation("_elements"), rowCount.getValue()));

                        }

                        if (this.parameters != null && this.parameters.getQuery() != null) {

                            this.history.add(searchParams);                   

                        }

                    } catch (Exception ex) {

                        LOGGER.warn(" Errors occurred during search getting old model", ex);

                        status.setTitle(i18n.getTranslation("_Errors_occurred_during_search"));

                    } finally {

                        setEnabled(true);

						status.terminate();

						this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

                    }

                });

            }

     }

    private Map<String, TableCellRenderer> getCustomRenderers(SearchParameters parameters) {

        FeatureType ft = this.store.getDefaultFeatureTypeQuietly();

        HashMap<String, TableCellRenderer> renderers = new HashMap<String, TableCellRenderer>();

        for (FeatureAttributeDescriptor attr : ft) {

            if(attr.getDataType().isNumeric()) {