gvSIG projects pool

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 gvSIG Association.

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License 

 * along with this program. If not, see <https://www.gnu.org/licenses/>. 

 * 

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.online.swing.impl;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionAdapter;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.function.Function;

import java.util.function.Predicate;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JTextField;

import javax.swing.ListCellRenderer;

import javax.swing.ListModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ChangeListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.text.JTextComponent;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import static org.gvsig.online.lib.api.OnlineManager.STATE_REMOTE_NEW;

import org.gvsig.online.lib.api.workingcopy.OnlineEntity;

import org.gvsig.online.lib.api.workingcopy.OnlineWorkingcopy;

import org.gvsig.online.swing.api.OnlineEntitySelectorController;

import static org.gvsig.online.swing.impl.OnlineSwingCommons.notInSwingThreadInvokeLater;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

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

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

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

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

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class OnlineEntitySelectorControllerJList extends AbstractDisposable implements OnlineEntitySelectorController

   {

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

   private final JTextComponent txtFilter;

   private final JList lstTables;

   private JListWithCheckbox lstTablesWithCheckbox;

   private final JButton btnTable;

   private FilteredListController filteredList;

   private ActionListenerSupport actionListeners;

   private ChangeListenerHelper changeListeners;

   private OnlineWorkingcopy workspace;

   private boolean processing;

   private boolean enabled;

   private Predicate<OnlineEntity> viewFilter;

   private Predicate<OnlineEntity> filter;

    private JButton btnCheckAll;

    private JButton btnUnCheckAll;

    private ArrayList<OnlineEntity> entities;

    private Thread lastThread;

    private Function<OnlineEntity, String> labelEntityFormatter;

    public OnlineEntitySelectorControllerJList(JList lstTables) {

        this(lstTables, null, null, null, null);

    }

    public OnlineEntitySelectorControllerJList(JList lstTables, JTextComponent txtFilter, JButton btnTable, JButton btnCheckAll, JButton btnUnCheckAll) {

        viewFilter = ALL_ENTITIES;

        filter = ALL_ENTITIES;

        this.lstTables = lstTables;

        this.lstTablesWithCheckbox = null;

        if( txtFilter==null ) {

            this.txtFilter = new JTextField();

        } else {

            this.txtFilter = txtFilter;

        }

        if( btnTable==null ) {

            this.btnTable = new JButton();

        } else {

            this.btnTable = btnTable;

        }

        if( btnCheckAll==null ) {

            this.btnCheckAll = new JButton();

        } else {

            this.btnCheckAll = btnCheckAll;

        }

        if( btnUnCheckAll==null ) {

            this.btnUnCheckAll = new JButton();

        } else {

            this.btnUnCheckAll = btnUnCheckAll;

        }

        this.lstTables.setCellRenderer(new ListCellRenderer() {

            JLabel label = new JLabel();

            @Override

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

                if( value instanceof OnlineEntity && workspace!=null ) {

                    this.label.setText(workspace.formatEntityLabel((OnlineEntity)value));

                } else {

                    this.label.setText(value.toString());

                }

                return this.label;

            }

        });

        this.processing = false;

        this.initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        this.actionListeners = toolsSwingManager.createActionListenerSupport();

        this.changeListeners = toolsSwingManager.createChangeListenerHelper();

        this.btnTable.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));

        this.lstTables.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        this.lstTables.addListSelectionListener(new ListSelectionListener() {

            boolean alreadyInEvent = false;

            @Override

            public void valueChanged(ListSelectionEvent e) {

                if( e.getValueIsAdjusting() || this.alreadyInEvent ) {

                    return;

                }

                try {

                    this.alreadyInEvent = true;

                    fireActionEvent(new ActionEvent(this, ACTION_SELECT_ID, ACTION_SELECT));

                } finally {

                    this.alreadyInEvent = false;

                }

            }

        });

        this.btnCheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                checkAll();

            }

        });

        this.btnUnCheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                clearChecks();

            }

        });

        this.lstTables.addMouseMotionListener(new MouseMotionAdapter() {

            @Override

            public void mouseMoved(MouseEvent e) {

                super.mouseMoved(e); 

                doMouseMoved(lstTables.locationToIndex(e.getPoint()));

            }

        });

        filteredList = toolsSwingManager.createFilteredListController(lstTables, txtFilter, btnTable);

        this.lstTables.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

    }

    private void doMouseMoved(int rowindex) {

        if(rowindex<0 ){

            return;

        }

        Object x = this.lstTables.getModel().getElementAt(rowindex);

        if(!(x instanceof LabeledValue)){

            this.lstTables.setToolTipText("");

            return;

        }

        LabeledValue lv = (LabeledValue)x;

        if (lv.getValue() instanceof OnlineEntity) {

            OnlineEntity entity = (OnlineEntity) lv.getValue();

            OnlineEntity lentity = workspace.getWorkspaceEntityByCode(entity.getEntityCode());

            String s;

//            if (StringUtils.isBlank(entity.getRepositoryRevisionCode())) { //Es entidad local nueva

//                s = OnlineSwingCommons.getStateDescription(

//                        ((OnlineEntity) entity).getState()

//                );

//            } else {

                s = OnlineSwingCommons.getStateDescription(

                        lentity == null ? STATE_REMOTE_NEW : lentity.getState()

                );

//            }

            if( StringUtils.equalsIgnoreCase(entity.getEntityCode(), entity.getLabel()) ) {

                s = "<html>"+entity.getLabelOrName()+"<br>"+s+"</html>";

            } else {

                s = "<html>"+entity.getLabel()+"<br>"+entity.getEntityName()+"<br>"+s+"</html>";

            }

            this.lstTables.setToolTipText(s);

        } else {

            this.lstTables.setToolTipText("");

        }

    }

    @Override

    public boolean isProcessing() {

        return this.processing;

    }

    @Override

    public OnlineEntity getSelectedEntity() {

        if( this.workspace==null ) {

            return null;

        }

        LabeledValue selected = (LabeledValue) lstTables.getSelectedValue();

        if (selected == null) {

            return null;

        }

        OnlineEntity entity = (OnlineEntity) selected.getValue();

        if(!this.filter.test(entity)){

            return null;

        }

        return entity;

    }

    @Override

    public void setSelectedEntity(OnlineEntity entity) {

        if( this.workspace==null ) {

            return;

        }

        ListModel model = lstTables.getModel();

        for (int i = 0; i < model.getSize(); i++) {

            OnlineEntity value = ((LabeledValue<OnlineEntity>)model.getElementAt(i)).getValue();

            if(StringUtils.equals(entity.getEntityCode(), value.getEntityCode())){

                lstTables.setSelectedIndex(i);

                return;

            }

        }

    }

    @Override

    public List<OnlineEntity> getCheckedEntities() {

        if (this.lstTablesWithCheckbox == null) {

            OnlineEntity entity = this.getSelectedEntity();

            if (entity == null) {

                return Collections.EMPTY_LIST;

            }

            return Collections.singletonList(this.getSelectedEntity());

        }

        List<OnlineEntity> checkedEntities = new ArrayList<>();

        ListSelectionModel checkedModel = this.lstTablesWithCheckbox.getCheckedModel();

        ListModel model = this.lstTablesWithCheckbox.getModel();

        for (int i = 0; i < model.getSize(); i++) {

            if(checkedModel.isSelectedIndex(i)){

                checkedEntities.add((OnlineEntity) ((LabeledValue) model.getElementAt(i)).getValue());

            }

        }

        return checkedEntities;      

    }

    @Override

    public void setWorkspace(OnlineWorkingcopy workspace) {

        DisposeUtils.disposeQuietly(workspace);

        this.workspace = workspace;

        DisposeUtils.bind(this.workspace);

        reloadEntities(true);

    }

    @Override

    public OnlineWorkingcopy getWorkspace() {

        return this.workspace;

    }

    @Override

    public void reloadEntities() {

        reloadEntities(true);

    }

    private void reloadEntities(boolean forceUpdateEntities) {

        this.filteredList.getModel().clear();

        if (workspace == null) { 

            postReloadTables(Collections.EMPTY_LIST);

            return;

        }

        Thread task = new Thread(() -> {reloadTables(this.workspace, forceUpdateEntities);}, "VCSGisEntitySelectorListReloadEntities");

        task.start();

        this.lastThread = task;

    }

    private boolean  isCancelled(){

        return Thread.currentThread() != this.lastThread;

    }

    private void reloadTables(OnlineWorkingcopy workspace, boolean forceUpdateEntities) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            fireActionEvent(new ActionEvent(this, ACTION_BEGIN_PROCESSING_ID, ACTION_BEGIN_PROCESSING));

            this.processing = true;

            this.doUpdateComponents();

//            if(forceUpdateEntities){

//                workspace.updateEntitiesFromRepository();

//            }

//            List<OnlineEntity> repoEntities = workspace.getRepositoryEntities();

            List<LabeledValue<OnlineEntity>> entities = new ArrayList<>();

//            for (OnlineEntity rentity : repoEntities) {

//                if(isCancelled()){

//                    return;

//                }

//                OnlineEntity lentity = workspace.getWorkspaceEntityByCode(rentity.getEntityCode());

//                LabeledValue entry;

//                String s = OnlineSwingCommons.getHTMLColorTag(

//                        lentity == null ? STATE_REMOTE_NEW : lentity.getState(),

//                        this.getLabelOfEntity(rentity)

//                );

//                if(lentity != null && this.viewFilter.test(lentity)){

//                        entry = new LabeledValueImpl(s, lentity);

//                        entities.add(entry);

//                } else {

//                    if(this.viewFilter.test(rentity)){

//                        entry = new LabeledValueImpl(s, rentity);

//                        entities.add(entry);

//                    }

//                }

//            }

            List<OnlineEntity> localEntities = workspace.getWorkspaceEntities();

            for (OnlineEntity localEntity : localEntities) {

                if(isCancelled()){

                    return;

                }

//                if (StringUtils.isBlank(localEntity.getRepositoryRevisionCode())) { //Es entidad local nueva

//                    if (!this.viewFilter.test(localEntity)) {

//                        continue;

//                    }

//                    LabeledValue entry;

//                    String s = OnlineSwingCommons.getHTMLColorTag(

//                            localEntity.getState(),

//                            this.getLabelOfEntity(localEntity)

//                    );

//                    entry = new LabeledValueImpl(s, localEntity);

//                    entities.add(entry);

//                }

            }

            Collections.sort(entities, (LabeledValue<OnlineEntity> o1, LabeledValue<OnlineEntity> o2) -> StringUtils.compareIgnoreCase(

                    o1.getValue().getLabelOrName(),

                    o2.getValue().getLabelOrName()

            ));

            if(!isCancelled()){

                postReloadTables(entities);

            }

        } catch (Exception e) {

            LOGGER.warn("_Cant_retrieve_entities_from_repository", e);

            if (!isCancelled()) {

                ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                dialogs.messageDialog(

                        i18n.getTranslation("_Cant_retrieve_entities_from_repository") + "\n" + e.getMessage(),

                        i18n.getTranslation("_VCS_Checkout"),

                        JOptionPane.WARNING_MESSAGE

                );

            }

        } finally {

            if (!isCancelled()) {

                this.processing = false;

                this.doUpdateComponents();

                fireActionEvent(new ActionEvent(this, ACTION_END_PROCESSING_ID, ACTION_END_PROCESSING));

            }

        }

    }

    private void postReloadTables(List<LabeledValue<OnlineEntity>> entities ) {

        if( notInSwingThreadInvokeLater(() -> { postReloadTables(entities); }) ) {

            return;

        }

        this.entities = new ArrayList<>();

        FilteredListModel model = this.filteredList.getModel();

        Set<String> checkeds = new HashSet<>();

        ListSelectionModel checkedModel = null;

        if(lstTablesWithCheckbox != null) {

            checkedModel = lstTablesWithCheckbox.getCheckedModel();

            for(int i = 0; i<model.getSize(); i++){

                if(checkedModel.isSelectedIndex(i)){

                    checkeds.add(((OnlineEntity) (model.getElementAt(i).getValue())).getEntityCode());

                }

            }

            checkedModel.clearSelection();

        }

        model.clear();

        this.lstTables.getSelectionModel().clearSelection();

        for (LabeledValue<OnlineEntity> entity : entities) {

            if(entity != null){

                this.entities.add(entity.getValue());

                model.addElement(entity);

            }

        }

        if(checkedModel != null) {

            for(int i = 0; i<model.getSize(); i++){

                OnlineEntity entity = (OnlineEntity) (model.getElementAt(i).getValue());

                if(checkeds.contains(entity.getEntityCode())){

                    checkedModel.addSelectionInterval(i, i);

                }

            }

        }

        this.processing = false;

        fireActionEvent(new ActionEvent(this, ACTION_RELOAD_ID, ACTION_RELOAD));

    }

    @Override

    public Collection<OnlineEntity> getEntities() {

        return this.entities;

    }

    private void doUpdateComponents() {

        if( notInSwingThreadInvokeLater(this::doUpdateComponents) ) {

            return;

        }

        this.txtFilter.setEnabled(enabled && !processing);

        this.btnTable.setEnabled(enabled && !processing);

        this.lstTables.setEnabled(enabled && !processing);

    }

    @Override

    public void setEnabled(boolean enabled) {

        this.enabled = enabled;

        doUpdateComponents();

    }

   @Override

    public boolean isEnabled() {

        return enabled;

    }

    @Override

    public void setChecksEnabled(boolean enabled) {

        if(enabled){

            lstTablesWithCheckbox = ToolsSwingLocator.getToolsSwingManager().createJListWithCheckbox(lstTables);

            lstTablesWithCheckbox.getCheckedModel().addListSelectionListener((ListSelectionEvent e) -> {

                if( e.getValueIsAdjusting() ) {

                    return;

                }

                fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

            });

        } else {

            lstTablesWithCheckbox = null;

        }

    }

    @Override

    public boolean isChecksEnabled() {

        return lstTablesWithCheckbox != null;

    }

    @Override

    public void addActionListener(ActionListener al) {

        this.actionListeners.addActionListener(al);

    }

    @Override

    public ActionListener[] getActionListeners() {

        return this.actionListeners.getActionListeners();

    }

    @Override

    public void removeActionListener(ActionListener al) {

        this.actionListeners.removeActionListener(al);

    }

    @Override

    public void removeAllActionListener() {

        this.actionListeners.removeAllActionListener();

    }

    @Override

    public void fireActionEvent(ActionEvent ae) {

        this.actionListeners.fireActionEvent(ae);

    }

    @Override

    public boolean hasActionListeners() {

        return this.actionListeners.hasActionListeners();

    }

    @Override

    public void addChangeListener(ChangeListener cl) {

        this.changeListeners.addChangeListener(cl);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return this.changeListeners.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener cl) {

        this.changeListeners.removeChangeListener(cl);

    }

    @Override

    public void removeAllChangeListener() {

        this.changeListeners.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return this.changeListeners.hasChangeListeners();

    }

   @Override

    public void setViewFilter(Predicate<OnlineEntity> viewFilter) {

        this.viewFilter = viewFilter;

        reloadEntities(false);

//        OnlineWorkingcopy ws = getWorkspace();

//        if (ws != null) {

//            Thread task = new Thread(() -> {reloadTables(this.workspace);}, "VCSGisEntitySelectorListReloadEntities");

//            task.start();

//        }

    }

   @Override

    public void setFilter(Predicate<OnlineEntity> filter) {

        this.filter = filter;

        reloadEntities(false);

//        OnlineWorkingcopy ws = getWorkspace();

//        if (ws != null) {

//            reloadTables(getWorkspace());

//        }

    }

   @Override

    public void check(OnlineEntity entity) {

        if (lstTablesWithCheckbox != null && entity != null) {

            ListModel model = this.filteredList.getModel();

            for (int i = 0; i < model.getSize(); i++) {

                LabeledValueImpl element = (LabeledValueImpl) model.getElementAt(i);

                OnlineEntity ent = (OnlineEntity) element.getValue();

                if (StringUtils.equalsIgnoreCase(

                        ent.getEntityCode(),

                        entity.getEntityCode()

                )) {

                    lstTablesWithCheckbox.getCheckedModel().addSelectionInterval(i, i);

                    fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

                    return;

                }

            }

        }

    }

   @Override

    public void unCheck(OnlineEntity entity) {

        if (lstTablesWithCheckbox != null && entity != null) {

            ListModel model = this.filteredList.getModel();

            for (int i = 0; i < model.getSize(); i++) {

                LabeledValueImpl element = (LabeledValueImpl) model.getElementAt(i);

                OnlineEntity ent = (OnlineEntity) element.getValue();

                if (StringUtils.equalsIgnoreCase(

                        ent.getEntityCode(),

                        entity.getEntityCode()

                )) {

                    lstTablesWithCheckbox.getCheckedModel().removeSelectionInterval(i, i);

                    fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

                    return;

                }

            }

        }

    }

    @Override

    public void clearChecks() {

        if(lstTablesWithCheckbox != null){

            lstTablesWithCheckbox.getCheckedModel().clearSelection();

            fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

        }

    }

    @Override

    public void checkAll() {

        lstTablesWithCheckbox.getCheckedModel().setSelectionInterval(0, lstTablesWithCheckbox.getModel().getSize());

        fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

    }

    public void setCheck(Collection<String> entityCodes, boolean check) {

        if (lstTablesWithCheckbox != null && !CollectionUtils.isEmpty(entityCodes)) {

            ListModel model = this.filteredList.getModel();

            ListSelectionModel checkedModel = lstTablesWithCheckbox.getCheckedModel();

            for (int i = 0; i < model.getSize(); i++) {

                LabeledValueImpl element = (LabeledValueImpl) model.getElementAt(i);

                OnlineEntity ent = (OnlineEntity) element.getValue();

                if( entityCodes.contains(ent.getEntityCode())) {

                    if( check ) {

                        checkedModel.addSelectionInterval(i, i);

                    } else {

                        checkedModel.removeSelectionInterval(i, i);

                    }

                }

            }

            fireActionEvent(new ActionEvent(this, ACTION_CHECK_ID, ACTION_CHECK));

        }

    }

    @Override

    public void clear() {

        this.setWorkspace(null);

    }

    @Override

    protected void doDispose() throws BaseException {

        DisposeUtils.disposeQuietly(this.workspace);

    }

    private String getLabelOfEntity(OnlineEntity entity) {

        if( this.labelEntityFormatter==null ) {

            return workspace.formatEntityLabel(entity);

//            return entity.getLabelOrName();

        }

        return this.labelEntityFormatter.apply(entity);

    }

    public void setLabelEntityFormatter(Function<OnlineEntity,String> formatter) {

        this.labelEntityFormatter = formatter;

    }

    @Override

    public String getCategory(OnlineEntity entity) {

        String category = entity.getFirstCategory();

        return category;

    }

    @Override

    public void collapseAll() {

    }

    @Override

    public void expandAll() {

    }

}