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.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.Objects;

import java.util.function.Function;

import java.util.function.Predicate;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.ListCellRenderer;

import javax.swing.ListModel;

import javax.swing.event.ChangeListener;

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.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 OnlineEntitySelectorControllerJComboBox extends AbstractDisposable implements OnlineEntitySelectorController {

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

    private final JComboBox cboTables;

    private final ActionListenerSupport actionListeners;

    private final ChangeListenerHelper changeListeners;

    private OnlineWorkingcopy workingcopy;

    private boolean processing;

    private boolean enabled;

    private ArrayList<OnlineEntity> entities;

    private Predicate<OnlineEntity> viewFilter;

    private Predicate<OnlineEntity> filter;

    private Thread lastThread;

    private Function<OnlineEntity, String> labelEntityFormatter;

    public OnlineEntitySelectorControllerJComboBox(JComboBox cboTables) {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        viewFilter = ALL_ENTITIES;

        filter = ALL_ENTITIES;

        this.cboTables = cboTables;

        this.processing = false;

        this.actionListeners = toolsSwingManager.createActionListenerSupport();

        this.changeListeners = toolsSwingManager.createChangeListenerHelper();

        this.initComponents();

    }

    private void initComponents() {

        this.cboTables.addItemListener(new ItemListener() {

            boolean alreadyInEvent = false;

            @Override

            public void itemStateChanged(ItemEvent e) {

                if( e.getStateChange()==ItemEvent.SELECTED ) {

                    try {

                        this.alreadyInEvent = true;

                        fireChangeEvent();

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

                    } finally {

                        this.alreadyInEvent = false;

                    }

                }

            }

        });

        this.cboTables.setRenderer(new ListCellRenderer() {

            JLabel label = new JLabel();

            @Override

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

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

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

                } else {

                    this.label.setText(Objects.toString(value, null));

                }

                return this.label;

            }

        });

    }

    @Override

    public boolean isProcessing() {

        return this.processing;

    }

    @Override

    public OnlineEntity getSelectedEntity() {

        if (this.workingcopy == null) {

            return null;

        }

        LabeledValue selected = (LabeledValue) cboTables.getSelectedItem();

        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.workingcopy == null) {

            return;

        }

        ListModel model = cboTables.getModel();

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

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

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

                cboTables.setSelectedIndex(i);

                return;

            }

        }

    }

    @Override

    public List<OnlineEntity> getCheckedEntities() {

        return Collections.EMPTY_LIST;

    }

    @Override

    public void setWorkspace(OnlineWorkingcopy workspace) {

        DisposeUtils.disposeQuietly(workspace);

        this.workingcopy = workspace;

        DisposeUtils.bind(this.workingcopy);

        reloadEntities();

    }

    @Override

    public OnlineWorkingcopy getWorkspace() {

        return this.workingcopy;

    }

    @Override

    public void reloadEntities() {

        DefaultComboBoxModel<LabeledValue<OnlineEntity>> model = new DefaultComboBoxModel<>();

        this.cboTables.setModel(model);

        if (workingcopy == null) {

            return;

        }

        Thread task = new Thread(() -> {

            reloadTables(this.workingcopy);

        }, "VCSGisEntitySelectorComboReloadEntities");

        task.start();

        this.lastThread = task;

    }

    private boolean  isCancelled(){

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

    }

    private void reloadTables(OnlineWorkingcopy workspace) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

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

            this.processing = true;

            this.doUpdateComponents();

//            workspace.updateEntitiesFromRepository();

            //FIXME: XXXXXXXXXXXXXXXXx

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

            List<LabeledValue<OnlineEntity>> theEntities = 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);

//                    theEntities.add(entry);

//                } else {

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

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

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

//                    theEntities.add(entry);

//                }

            }

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

                    o1.getValue().getLabelOrName(),

                    o2.getValue().getLabelOrName()

            ));

            if (!isCancelled()) {

                postReloadTables(theEntities);

            }

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

        DefaultComboBoxModel<LabeledValue<OnlineEntity>> model = new DefaultComboBoxModel<>();

        model.addElement(new LabeledValueImpl<>("", null));        

        for (LabeledValue<OnlineEntity> entity : entities) {

            if (entity != null) {

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

                model.addElement(entity);

            }

        }

        this.cboTables.setModel(model);

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

    }

    @Override

    public boolean isChecksEnabled() {

        return false;

    }

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

    }

    private void fireChangeEvent() {

        this.changeListeners.fireEvent();

    }

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

    }

    @Override

    public void setFilter(Predicate<OnlineEntity> filter) {

        this.filter = filter;

        reloadEntities();

    }

    @Override

    public void check(OnlineEntity entity) {

    }

    @Override

    public void unCheck(OnlineEntity entity) {

    }

    @Override

    public void clearChecks() {

    }

    @Override

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

    }

    @Override

    public void checkAll() {

    }

    @Override

    public void clear() {

        this.setWorkspace(null);

    }

    @Override

    protected void doDispose() throws BaseException {

        DisposeUtils.disposeQuietly(this.workingcopy);

    }

    private String getLabelOfEntity(OnlineEntity entity) {

        if( this.labelEntityFormatter==null ) {

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

    }

}