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.net.URL;

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.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 javax.swing.JMenuItem;

import javax.swing.JOptionPane;

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.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.StringUtils;

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

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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.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.impl.featurequery.DefaultFeatureQueryGroupByPanel;

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.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

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

import org.gvsig.tools.util.ToolsUtilLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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.SearchParameters;

import org.gvsig.tools.bookmarksandhistory.Bookmark;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

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.locator.ReferenceNotRegisteredException;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.PropertiesSupportHelper;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings({"UseSpecificCatch"})

public class DefaultSearchPanel

        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;

//                DataSwingManager manager = DALSwingLocator.getDataSwingManager();

//                SearchPostProcessFactory factory= manager.getSearchPostProcess(this.panel.currentPostProcess);

//                SearchParameters searchParams = this.panel.parameters.getCopy();

//                if (factory.hasProcessParameters()){

//                    SearchPostProcess.SearchPostProcessResult searchPostProcessResult = this.panel.doExecuteSearchPostProcess(this.panel.store, this.panel.parameters.getQuery(), factory, this.panel.postProcessParams, searchParams);

//                    return searchPostProcessResult.getStore();

//                }

//                SearchPostProcess.SearchPostProcessResult searchPostProcessResult = this.panel.doExecuteSearchPostProcess(this.panel.store, this.panel.parameters.getQuery(), factory, null, searchParams);

//                return searchPostProcessResult.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.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;

//                DataSwingManager manager = DALSwingLocator.getDataSwingManager();

//                SearchPostProcessFactory factory= manager.getSearchPostProcess(this.panel.currentPostProcess);

//                SearchParameters searchParams =this.panel.parameters.getCopy();

//                if (factory.hasProcessParameters()){

//                    SearchPostProcess.SearchPostProcessResult searchPostProcessResult = this.panel.doExecuteSearchPostProcess(this.panel.store, this.panel.parameters.getQuery(), factory, this.panel.postProcessParams, searchParams);

//                    return searchPostProcessResult.getQuery();

//                }

//                SearchPostProcess.SearchPostProcessResult searchPostProcessResult = this.panel.doExecuteSearchPostProcess(this.panel.store, this.panel.parameters.getQuery(), factory, null, searchParams);

//                return searchPostProcessResult.getQuery();

                        }

                }

        }

//    private class SearchPostProcessListener implements ActionListener {

//

//        private final FeatureStore input;

//        private final SearchPostProcessFactory factory;

//        private final FeatureQuery query;

//

//        public SearchPostProcessListener(

//                FeatureStore input,

//                FeatureQuery query,

//                SearchPostProcessFactory factory

//        ) {

//            this.input = input;

//            this.query = query;

//            this.factory = factory;

//        }

//

//        @Override

//        public void actionPerformed(ActionEvent e) {

//            // habilita la pesta�a del tab con los resultados del post procesado

//            if (this.factory.hasProcessParameters()) {

//                DynObject parameters = this.factory.createProcessParameters(this.input);

//                JDynForm form = DynFormLocator.getDynFormManager().createJDynForm(parameters);

//                form.asJComponent().setPreferredSize(new Dimension(350, 250));

//

//                I18nManager i18n = ToolsLocator.getI18nManager();

//                WindowManager_v2 windowManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

//

//                Dialog dialog = windowManager.createDialog(

//                        form.asJComponent(),

//                        i18n.getTranslation("_create_parameters"),

//                        i18n.getTranslation("_parameters_list"),

//                        WindowManager_v2.BUTTONS_OK_CANCEL);

//

//                dialog.addActionListener((ActionEvent e2) -> {

//                    if (dialog.getAction() == WindowManager_v2.BUTTON_OK) {

//                        form.getValues(parameters); // actualiza el valor de lo los parametros con los valores introducidos por el usuario

//                        doExecuteSearchPostProcess(this.input, this.query, this.factory, parameters);

//                        postProcessParams = parameters;

//                    }

//                });

//

//                dialog.show(WindowManager.MODE.DIALOG);

//

//            } else {

//                doExecuteSearchPostProcess(this.input, this.query, this.factory, null);

//            }

//        }

//    }

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

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

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

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

                                                searchParams.fix(this.getFeatureType());

                                                // TODO: habria que comprobar y preguntar al usuario de forma

                                                // similar a lo que se hace en DefaultFeatureQueryCalculatedColumnsPanel.doRemove

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

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

        }

        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;

//                myQuery = this.getQuery().getCopy();

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

                                }

                        });

                }

        }

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

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

                        }

                }

                return renderers;

        }

        private void resetTable() {

                if (!SwingUtilities.isEventDispatchThread()) {

                        SwingUtilities.invokeLater(this::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);

        }

        @Override

        public boolean setFilter(Expression filter) {

                try {

                        if (this.conditionPanels == null) {

                                this.initComponents();

                        }

                        if (ExpressionUtils.isPhraseEmpty(filter)) {

                                this.clear();

                                return true;

                        }

                        int panel = 0;

                        int selected = PANEL_ADVANCED;

                        for (SearchConditionPanel conditionPanel : conditionPanels) {

                                if (panel != PANEL_ADVANCED && conditionPanel.set(filter)) {

                                        selected = panel;

                                }

                                panel++;

                        }

                        this.tabSearchMode.setSelectedIndex(selected);

//            SimpleFeaturesTableModel model = new SimpleFeaturesTableModel(this.getStore());

//            tblResults.setModel(model);

//            lblMsg.setText("");

                        return true;

                } catch (Exception ex) {

                        LOGGER.warn("Can't set current search", ex);

                        return false;

                }

        }

        @Override

        public List<SearchConditionPanel> getConditionPanels() {

                return Collections.unmodifiableList(this.conditionPanels);

        }

        @Override

        public SearchConditionPanel getConditionPanel(String name) {

                if (conditionPanels == null) {

                        return null;

                }

                for (SearchConditionPanel panel : conditionPanels) {

                        if (StringUtils.equalsIgnoreCase(name, panel.getFactory().getName())) {

                                return panel;

                        }

                }

                return null;

        }

        @Override

        public Expression getFilterForSelectedFeature() {

                if (this.conditionPanels == null) {

                        return null;

                }

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

                        int selectedRow = this.tblResults.getSelectedRow();

                        if (selectedRow < 0) {

                                return null;

                        }

                        try {

                                List<Feature> features = ((SimpleFeaturesTableModelImpl) this.tblResults.getModel()).getFeatures();

                                Feature feature = features.get(selectedRow);

                                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                                FeatureType ftype = this.store.getDefaultFeatureType();

                                for (FeatureAttributeDescriptor attrdesc : ftype.getPrimaryKey()) {

                                        builder.and(

                                                builder.eq(

                                                        builder.column(attrdesc.getName()),

                                                        builder.constant(feature.get(attrdesc.getName()))

                                                )

                                        );

                                }

                                Expression filter = ExpressionUtils.createExpression(builder.toString());

                                return filter;

                        } catch (Exception ex) {

                                LOGGER.warn("Can't build search for the selected feature.", ex);

                                return null;

                        }

                } else {

                        if (this.currentPostProcess == null) {

                                return null;

                        }

                        int selectedRow = this.tblSearchPostProcessResults.getSelectedRow();

                        if (selectedRow < 0) {

                                return null;

                        }

                        try {

                                List<Feature> features = ((SimpleFeaturesTableModelImpl) this.tblSearchPostProcessResults.getModel()).getFeatures();

                                Feature feature = features.get(selectedRow);

                                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                                FeatureType ftype = this.postProcessStore.getDefaultFeatureType();

                                for (FeatureAttributeDescriptor attrdesc : ftype.getPrimaryKey()) {

                                        builder.and(

                                                builder.eq(

                                                        builder.column(attrdesc.getName()),

                                                        builder.constant(feature.get(attrdesc.getName()))

                                                )

                                        );

                                }

                                Expression filter = ExpressionUtils.createExpression(builder.toString());

                                return filter;

                        } catch (Exception ex) {

                                LOGGER.warn("Can't build search for the selected feature.", ex);

                                return null;

                        }

                }

        }

        @Override

        public FeatureStore getStore() {

                return store;

        }

        private void doOrderBy() {

                I18nManager i18n = ToolsLocator.getI18nManager();

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

                FeatureQueryOrderPanel orderPanel = DALSwingLocator.getDataSwingManager().createFeatureStoreOrderPanel();

                orderPanel.setStore(store);

                orderPanel.put(parameters.getQuery());

                Dialog dialog = windowManager.createDialog(

                        orderPanel.asJComponent(),

                        i18n.getTranslation("_Select_order"),

                        null,

                        WindowManager_v2.BUTTONS_OK_CANCEL

                );

                dialog.addActionListener((ActionEvent e) -> {

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

                                orderPanel.fetch(this.parameters.getQuery());

                                search();

                        }

                });

                dialog.show(WindowManager.MODE.DIALOG);

        }

        private void doCopyRows(JTable table) {

                Cursor savedCursor = this.getCursor();

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

                status.setAutoremove(true);

                status.add();

                this.taskStatusController.bind(status);

                Thread task = new Thread(() -> {

                        try {

                                this.processing = true;

                                this.updateComponentState();

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

                                SwingUtilities.invokeLater(() -> {

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

                                });

                                SimpleFeaturesTableModel model = null;

                                if (table.getModel() instanceof SimpleFeaturesTableModel) {

                                        model = (SimpleFeaturesTableModel) table.getModel();

                                }

                                String LINE_BREAK = System.lineSeparator();

                                String CELL_BREAK = "\t";

                                char DELIMITER = '"';

                                int[] selection = table.getSelectedRows();

                                for (int i = 0; i < selection.length; i++) {

                                        selection[i] = table.convertRowIndexToModel(selection[i]);

                                }

                                int numCols = table.getColumnCount();

                                StringBuilder excelStr = new StringBuilder();

                                boolean valueIsNumeric;

                                for (int j = 0; j < numCols; j++) {

                                        excelStr.append(DELIMITER);

                                        excelStr.append(escape(table.getColumnName(j), LINE_BREAK, CELL_BREAK));

                                        excelStr.append(DELIMITER);

                                        if (j < numCols - 1) {

                                                excelStr.append(CELL_BREAK);

                                        }

                                }

                                //from( 0, selection.length)

                                status.setRangeOfValues(0, selection.length);

                                excelStr.append(LINE_BREAK);

                                for (int i : selection) {

                                        status.incrementCurrentValue();

                                        if (status.isCancellationRequested()) {

                                                status.message("");

                                                status.cancel();

                                                return;

                                        }

                                        for (int j = 0; j < numCols; j++) {

                                                valueIsNumeric = false;

                                                FeatureAttributeDescriptor descriptor = null;

                                                if (model != null) {

                                                        descriptor = model.getFeatureDescriptor(j);

                                                        if (descriptor.getDataType().isNumeric()) {

                                                                if (!descriptor.hasAvailableValues()) {

                                                                        valueIsNumeric = true;

                                                                }

                                                        }

                                                }

                                                if (!valueIsNumeric) {

                                                        excelStr.append(DELIMITER);

                                                }

                                                Object value = table.getValueAt(i, j);

                                                String valueStr;

                                                if (descriptor != null) {