Application: gvSIG desktop

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

import java.awt.BorderLayout;

import java.awt.Cursor;

import java.awt.FlowLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.nio.charset.Charset;

import java.sql.SQLException;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import javax.swing.AbstractAction;

import javax.swing.Action;

import static javax.swing.Action.ACTION_COMMAND_KEY;

import static javax.swing.Action.NAME;

import javax.swing.BorderFactory;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComponent;

import static javax.swing.JFileChooser.FILES_ONLY;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import static javax.swing.JOptionPane.YES_OPTION;

import javax.swing.JPopupMenu;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.filechooser.FileFilter;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableModel;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang.mutable.MutableObject;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableLong;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import static org.gvsig.filedialogchooser.FileDialogChooser.SAVE_DIALOG;

import static org.gvsig.fmap.dal.DataManager.USE_LABELS_BOTH;

import static org.gvsig.fmap.dal.DataManager.USE_LABELS_NO;

import static org.gvsig.fmap.dal.DataManager.USE_LABELS_YES;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.complements.Search;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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

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.feature.paging.FacadeOfAFeaturePagingHelper;

import org.gvsig.fmap.dal.swing.AbstractDALActionFactory.AbstractDALActionContext;

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

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

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

import org.gvsig.fmap.dal.swing.featurequery.FeatureQueryCalculatedColumnsPanel;

import org.gvsig.fmap.dal.swing.featurequery.FeatureQueryOrderPanel;

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

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

import org.gvsig.fmap.dal.swing.impl.DefaultDALSwingLibrary;

import static org.gvsig.fmap.dal.swing.impl.DefaultDALSwingLibrary.LIBRARY_NAME;

import org.gvsig.fmap.dal.swing.impl.featurequery.DefaultFeatureQueryCalculatedColumnsPanel;

import org.gvsig.fmap.dal.swing.impl.featuretable.SimpleFeaturesTableModelImpl;

import org.gvsig.fmap.dal.swing.searchPostProcess.SearchPostProcess;

import org.gvsig.fmap.dal.swing.searchPostProcess.SearchPostProcessFactory;

import org.gvsig.fmap.dal.swing.searchpanel.FeatureStoreSearchPanel;

import org.gvsig.fmap.dal.swing.searchpanel.SearchConditionPanel;

import org.gvsig.fmap.dal.swing.searchpanel.SearchConditionPanel.SearchConditionPanelFactory;

import org.gvsig.fmap.dal.swing.searchpanel.SearchParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmark;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynform.DynFormLocator;

import org.gvsig.tools.dynform.JDynForm;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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_SETNAME;

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.BookmarksController.BookmarkEvent;

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

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.task.SimpleTaskStatus;

import org.gvsig.tools.util.ListBuilder;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.gvsig.tools.util.ToolsUtilLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings({"UseSpecificCatch"})

public class DefaultSearchPanel

        extends DefaultSearchPanelView2

        implements FeatureStoreSearchPanel, SupportIsEnable, SupportIsVisible {

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

        private static final String EXPORT_TO_TSV_TITLE="_Export_to_TSV";

        private static final String EXPORT_TO_TSV_LASTPATHID="exporttotsv.lastpath";

        private static final String TSV_EXTENSION="tsv";

        private BookmarksController bookmarksController;

        private HistoryController historyController;

        private FeatureQuery lastQuery;

        private Feature lastSelectedFeature;

        private final PropertiesSupportHelper propertiesHelper;

        private TaskStatusController taskStatusController;

        private boolean automaticallySearch;

        private String lastErrorMessage;

        private boolean initialized;

        private boolean postProcessEnabled;

        private boolean groupByEnabled;

        private Map<String,AdditionalResultsPanel> additionalResultsPanels;

        private static class AdditionalResultsPanel implements Component {

            private final String name;

            private final String title;

            private int index;

            private final Component component;

            public AdditionalResultsPanel(String name, String title, Component component, int index) {

                this.name = name;

                this.title = title;

                this.component = component;

                this.index = index;

            }

            public AdditionalResultsPanel(String name, String title, Component component) {

                this(name, title, component,-1);

            }

            public String getName() {

                return this.name;

            }

            public String getTitle() {

                return title;

            }

            public int getIndex() {

                return this.index;

            }

            @Override

            public JComponent asJComponent() {

                return this.component.asJComponent();

            }

            public void setIndex(int index) {

                this.index = index;

            }

            public void fireActionEvent(ActionEvent e) {                

                if( this.component instanceof ActionListenerSupport ) {

                    ((ActionListenerSupport)this.component).fireActionEvent(e);

                }

            }

            public void doDispose() {

                DisposeUtils.dispose(this.component);

            }

        }

        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) {

                    DALSwingLocator.getDataSwingManager().setUseLabels(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) {

                    DALSwingLocator.getDataSwingManager().setUseLabels(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) {

                    DALSwingLocator.getDataSwingManager().setUseLabels(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();

                }

        }

        public static class PropertiesAction extends AbstractAction {

                @SuppressWarnings("OverridableMethodCallInConstructor")

                public PropertiesAction() {

                        I18nManager i18n = ToolsLocator.getI18nManager();

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

                        this.putValue(ACTION_COMMAND_KEY, "Properties");

                }

                @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("_Properties");

                        }

                        return super.getValue(key);

                }

                @Override

                public void actionPerformed(ActionEvent ae) {

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

                        panel.doShowProperties();

                }

        }

        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);

                        JMenuItem exportTSVActionMenu = new JMenuItem(i18n.getTranslation(EXPORT_TO_TSV_TITLE));

                        exportTSVActionMenu.addActionListener((ActionEvent e) -> {

                                doExportTSV(table);

                        });

                        this.add(exportTSVActionMenu);

                }

        }

        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() == 1) {

                                return this.panel.postProcessStore;

                        } else {

                                return this.panel.getStore();

                        }

                }

                @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.getFilterForSelectedFeatures();

                }

                @Override

                public FeatureSelection getSelecteds() {

                        return this.panel.getSelectedFeatures();

                }

                @Override

                public FeatureQuery getQuery() {

                        if (this.panel.currentPostProcess != null && this.panel.tabResults.getSelectedIndex() == 1) {

                            return this.panel.postProcessQuery;

                        } else {

                            SearchParameters searchParams = this.panel.parameters;                            

                            FeatureQuery query = searchParams.getQueryToApply();

                            if( panel.useSelection() ) {

                                query = panel.addSelection(panel.store, query);

                            }

                            return query;

                        }

                }

        }

        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();

                this.additionalResultsPanels = new HashMap<>();

                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);

                this.automaticallySearch = true;

                this.postProcessEnabled = true;

                this.groupByEnabled = true;

                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);

                this.initComponents0();

                this.initialized = false;

        }

        @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());

                for (AdditionalResultsPanel additionalResultsPanel : this.additionalResultsPanels.values()) {

                    additionalResultsPanel.doDispose();

                }                

        }

        @Override

        public JComponent asJComponent() {

                if (!this.initialized) { //this.conditionPanels == null) {

                        this.initComponents1();

                }

                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);

                actionContext.set("searchpanel", this);

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

                for (DALActionFactory factory : factories) {

                    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 initComponents0() {

                this.conditionPanels = new ArrayList<>();

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

                        this.lblStatusTitle,

                        this.lblMsg,

                        this.pgbStatus);

        }

        private void initComponents1() {

                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);

                swingManager.translate(this.chkUseSelection);

                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.pgbStatus.setVisible(false);

                this.conditionPanels.add(

                        new SearchConditionPanelSimplified(

                                parameters,

                                store,

                                this.pnlConditionField,

                                btnAddAccumulatedFilter,

                                btnRemoveAccumulatedFilter,

                                btnViewAccumulatedFilter

                        )

                );

                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 + "'.", th);

                        }

                }

                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);

//        this.setPreferredSize(new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT));

                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);

                this.historyController.addActionListener((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;

                                        }

                                        putParametersAndSearch(b.getCurrentValue());

                                        break;

                        }

                });

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

                        BookmarkEvent<DefaultSearchParameters> b = (BookmarkEvent<DefaultSearchParameters>) e;

                        switch (b.getID()) {

                                case ID_GETVALUE:

                                    LOGGER.info("Save bookmark");

                                        DefaultSearchParameters actualParams = (DefaultSearchParameters) fetch(null);

                                        b.setCurrentValue(actualParams);

                                        break;

                                case ID_SETVALUE:

                                    LOGGER.info("Restore bookmark");

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

                                                return;

                                        }

                                        b.getBookmark().used();

                                        b.getCurrentValue().setName(b.getBookmark().getName());

                                        putParametersAndSearch(b.getCurrentValue());

                                        break;

                                case ID_SETNAME:

                                    LOGGER.info("Rename bookmark");

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

                                                return;

                                        }

                                        b.getCurrentValue().setName(b.getBookmark().getName());

                                        break;

                        }

                });

                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.tabResults.addChangeListener((ChangeEvent evt) -> {

                        SwingUtilities.invokeLater(() -> {

                                switch(tabResults.getSelectedIndex()) {

                                    case 1:

                                        updateNumberElementsMsg(resultPostProcessModel);

                                        break;

                                    case 0:

                                    default:

                                        updateNumberElementsMsg(resultModel);

                                }

                        });

                });

                this.tblResults.getTableHeader().setReorderingAllowed(false);

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

                this.tblSearchPostProcessResults.getTableHeader().setReorderingAllowed(false);

                if (this.filterOnlyMode || !this.postProcessEnabled) {

                        this.btnSearchPostProcess.setVisible(false);

                }

                for (SearchResultsPanelFactory factory : DALSwingLocator.getManager().getSearchResultsPanels()) {

                        String factoryName = "unknown";

                        try {

                            factoryName = factory.getName();

                            this.addResultPanel(

                                    factory.getName(),

                                    factory.getTitle(),

                                    factory.create(this)

                                );

                        } catch (Throwable th) {

                                LOGGER.warn("Can't create results panel '" + factoryName + "'.",th);

                        }

                }

                for (AdditionalResultsPanel panel : this.additionalResultsPanels.values()) {

                    panel.setIndex(this.tabResults.getTabCount());

                    this.tabResults.addTab(panel.getTitle(), panel.asJComponent());

                }

                this.initialized = true;

                if (this.automaticallySearch){

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

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

                            initBookmark.used();

                            putParametersAndSearch(initBookmark.getValue());

                    } else {

                        clear();

                        search();

                    }

                } else {

                    clear();

                }

        }

    private void putParametersAndSearch(DefaultSearchParameters searchParams) {

        DefaultSearchParameters params;

        try {

            params = searchParams.getCopy();

            FeatureType featType = this.getFeatureType();

            StringBuilder errMessage = new StringBuilder();

            boolean onlyEssentials = false;

            boolean isValid = params.isValid(featType, errMessage);

            if(!isValid){

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                I18nManager i18n = ToolsLocator.getI18nManager();

                int n = dialogs.confirmDialog(

                        i18n.getTranslation("_The_validation_of_the_search_parameters_has_returned_the_following_errors")+":\n\n"+errMessage.toString()+"\n"+i18n.getTranslation("_You_want_the_application_to_try_to_resolve_them_before_launching_the_query"),

                        i18n.getTranslation("_Validation_of_search_parameters"),

                        JOptionPane.YES_NO_OPTION,

                        JOptionPane.WARNING_MESSAGE,

                        "_Fix_search_parameters"

                );

                if( n != JOptionPane.YES_OPTION ) {

                    onlyEssentials = true;

                } else {

                    LOGGER.info("It has been decided do not resolve errors in parameters of search");

                }

            }

            params.fix(featType, onlyEssentials);

        } catch (Exception ex) {

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

            return;

        }

        SearchParameters panelParams;

        try {

            clear();

            put(params);

            panelParams = this.fetch(this.parameters.getCopy()); 

        } catch (Exception ex) {

                LOGGER.warn("Not able to create search parameters.", ex);

                this.taskStatusController.setTitle(ToolsLocator.getI18nManager().getTranslation("_Errors_fetching_new_query") + "...");

                resetTable();

                return;

        }

        Thread th = new Thread(() -> {

            doSearch(panelParams);

        });

        th.start();

    }

        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.initialized) { //this.conditionPanels == null) {

                        this.initComponents1();

                }

                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.initialized) { //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;

        }

        public String getWarnings() {

                int searchMode = this.tabSearchMode.getSelectedIndex();

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

                String s = panel.getWarnings();

                if( StringUtils.isBlank(s) ) {

                    return null;

                }

                return s;

        }

        @Override

        public int 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 STATUS_NOT_VALID;

                }

                String warnings = this.getWarnings();

                if( StringUtils.isNotBlank(warnings) ) {

                        ThreadSafeDialogsManager dialogManager = ToolsSwingLocator.getThreadSafeDialogsManager();

                        int n = dialogManager.confirmDialog(

                                "The indicated search can cause problems." + 

                                        "\n" + warnings + "\n" +

                                        "Do you want to run it anyway?",

                                "_Search",

                                JOptionPane.YES_NO_OPTION,

                                JOptionPane.WARNING_MESSAGE

                        );

                        if( n == JOptionPane.NO_OPTION ) {

                            return STATUS_OK;

                        }

                }

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

                setEnabled(false);

                Thread th = new Thread(() -> {

                        try {

                                SearchParameters searchParams;

                                try {

                                        searchParams = this.fetch(this.parameters.getCopy()); // esto lo actualiza a la ultima // decidir si se devuelve clonado

                                        Date date = Calendar.getInstance().getTime();

                                        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

                                        String strDate = dateFormat.format(date);

                                        searchParams.setName("Params: " + strDate);

                                } catch (Exception ex) {

                                        LOGGER.warn("Not able to create search parameters.", ex);

                                        this.taskStatusController.setTitle(ToolsLocator.getI18nManager().getTranslation("_Errors_fetching_new_query") + "...");

                                        resetTable();

                                        return;

                                }

                                doSearch(searchParams);

                        } catch (Exception ex) {

                                LOGGER.warn("Search panel has errors during the search", ex);

                                resetTable();

                        } finally {

                                SwingUtilities.invokeLater(() -> {

                                        setEnabled(true);

                                });

                        }

                });

                th.start();

                return STATUS_OK;

        }

        @Override

        public int search(SearchParameters searchParams) {

            ((DefaultSearchParameters)searchParams).fix(this.getFeatureType());

            return doSearch(searchParams);

        }

        private synchronized int 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);

                List<Feature> features = null;

                try {

                    LOGGER.info("Do search");

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

                        SwingUtilities.invokeLater(() -> {

                            if(this.initialized){

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

                            }

                        });

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

                        FeatureQuery myQuery = searchParams.getQueryToApply();

                        if( this.useSelection() ) {

                            myQuery = this.addSelection(this.store, myQuery);

                        }

                        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(features.size());

                        if(rowCount.longValue() > 0){

                            //Force to get first row in this thread

                            Feature f = features.get(0);

                        }

                        resultModel = (SimpleFeaturesTableModel) model.getValue();

                        SwingUtilities.invokeLater(() -> {

                            if(this.initialized){

                                I18nManager i18n = ToolsLocator.getI18nManager();

                                try {

                                        if( this.tabResults.getSelectedIndex()==1 ) {

                                            this.tabResults.setSelectedIndex(0);

                                        }

                                        TableModel oldmodel = tblResults.getModel();

                                        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);

                                        }

                                        this.fireSearchEvent();

                                } 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(savedCursor);

                                }

                            }

                        });

                } 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();

                        DisposeUtils.disposeQuietly(features);

                        this.lastErrorMessage = this.getLastErrorMessage(ex);

                        if(StringUtils.isNotBlank(this.lastErrorMessage)){

                            status.setTitle(this.lastErrorMessage);

                        }

                        resetTable();

                        return STATUS_ERROR1;

                }

                return STATUS_OK;

        }

        @Override

        public SimpleFeaturesTableModel getResultsTableModel() {

            return this.resultModel;

        }

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

                FeatureType ft = this.store.getDefaultFeatureTypeQuietly();

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

                for (FeatureAttributeDescriptor attr : ft) {

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

//                renderers.put(attr.getName(), new ColorRangeRenderer(attr, 20, 50));

                        }

                }

                return renderers;

        }

        private void resetTable() {

                if (!SwingUtilities.isEventDispatchThread()) {

                        SwingUtilities.invokeLater(() -> {

                            if(this.initialized){

                                resetTable();

                            }

                        });

                        return;

                }

                List<String> resultColumnNames = null;

                try {

                        resultColumnNames = this.parameters.getResultColumnNames();

                } catch (Exception ex) {

                }

                FeatureType ftype = this.store.getDefaultFeatureTypeQuietly();

                SimpleFeaturesTableModelImpl emptyTableModel = new SimpleFeaturesTableModelImpl(

                        ftype,

                        resultColumnNames,

                        null

                );

                this.tblResults.setModel(emptyTableModel);

        }

        public void setResultColumnNames(List<String> names) {

                this.parameters.getResultColumnNames().clear();

                this.parameters.getResultColumnNames().addAll(names);

//        if (this.conditionPanels == null) {

//            return;

//        }

//        SimpleFeaturesTableModelImpl model;

////        model = (SimpleFeaturesTableModel) this.tblResults.getModel();

//        List<Feature> features = store.getFeatures(this.parameters.getQuery());

//        FacadeOfAFeaturePagingHelper facade = (FacadeOfAFeaturePagingHelper) features;

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

//        model = new SimpleFeaturesTableModelImpl(

//                ftype,

//                this.parameters.getResultColumnNames(),

//                features

//        );

//        tblResults.setModel(model);