Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.swing.impl;

import java.util.AbstractList;

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

import java.util.List;

import java.util.Objects;

import javax.swing.AbstractListModel;

import javax.swing.DefaultListModel;

import javax.swing.ListModel;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.AbstractCancellableTask;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

/**

 *

 * @author jjdelcerro

 */

class FilteredListModelImpl extends AbstractListModel implements FilteredListModel {

    private static class ListModelToListAdapter extends AbstractList {

        private final ListModel model;

        public ListModelToListAdapter(ListModel model) {

            this.model = model;

        }

        @Override

        public Object get(int index) {

            return this.model.getElementAt(index);

        }

        @Override

        public int size() {

            return this.model.getSize();

        }

        @Override

        public Object set(int index, Object element) {

            if (!(model instanceof DefaultListModel)) {

                throw new IllegalStateException("The model is unmodifiable.");

            }

            return ((DefaultListModel) this.model).set(index, element);

        }

    }

    private ListModel elements;

    private DefaultListModel<LabeledValue> filteredElements;

    private String filter;

    private AbstractCancellableTask th;

    private FilterFunction filterfn;

    private boolean caseSensitive = false;

    public FilteredListModelImpl(ListModel model) {

        if (model == null) {

            this.elements = new DefaultListModel();

        } else {

            this.elements = model;

        }

        this.filteredElements = new DefaultListModel();

        this.filter = null;

        this.th = null;

        final I18nManager i18n = ToolsLocator.getI18nManager();

        this.filterfn = (Object theModel, Object item, String theFilter) -> {

            if (item == null) {

                return false;

            }

            if (StringUtils.isBlank(theFilter)) {

                return true;

            }

            theFilter = theFilter.toLowerCase();

            if (FilenameUtils.wildcardMatch(item.toString().toLowerCase(), theFilter)) {

                return true;

            }

            if (item instanceof LabeledValue) {

                LabeledValue labeledValue = (LabeledValue) item;

                String label = labeledValue.getLabel();

                if (label != null) {

                    if (FilenameUtils.wildcardMatch(label.toLowerCase(), theFilter)) {

                        return true;

                    }

                    if (FilenameUtils.wildcardMatch(i18n.getTranslation(label).toLowerCase(), theFilter)) {

                        return true;

                    }

                }

            }

            return false;

        };

    }

    @Override

    public void setFilterFunction(FilterFunction filter) {

        this.filterfn = filter;

    }

    @Override

    public synchronized ListModel getModel() {

        return this.elements;

    }

    @Override

    public synchronized int getSize() {

        return this.filteredElements.getSize();

    }

    @Override

    public synchronized void clear() {

        this.elements = new DefaultListModel();

        this.filteredElements = new DefaultListModel();

        this.filter = null;

        fireContentsChanged();

    }

    @Override

    public synchronized LabeledValue getElementAt(int index) {

        return this.filteredElements.getElementAt(index);

    }

    @Override

    public synchronized void addElement(LabeledValue element) {

        if (element == null) {

            return;

        }

        if (!(elements instanceof DefaultListModel)) {

            throw new IllegalStateException("The model is unmodifiable.");

        }

        ((DefaultListModel) this.elements).addElement(element);

        if (this.filterfn.test(this, element, filter)) {

            this.filteredElements.addElement(element);

        }

        fireContentsChanged();

    }

    @Override

    public synchronized void addElement(Object element) {

        if (!(element instanceof LabeledValue)) {

            element = new LabeledValueImpl<>(Objects.toString(element, ""), element);

        }

        this.addElement((LabeledValue) element);

    }

    @Override

    public synchronized void setFilter(String filter) {

        if (StringUtils.isBlank(filter)) {

            this.filter = null;

        } else {

            if (StringUtils.containsAny(filter, "*?")) {

                this.filter = filter;

            } else {

                this.filter = "*" + filter + "*";

            }

        }

        this.copy(elements, filteredElements, this.filter);

        fireContentsChanged();

    }

    private synchronized void copy(ListModel source, DefaultListModel target, String filter) {

        target.clear();

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

            Object item = source.getElementAt(i);

            try {

                if (this.filterfn.test(this, item, filter)) {

                    target.addElement(item);

                }

            } catch (Exception e) {

                target.addElement(item);

            }

        }

    }

    private void fireContentsChanged() {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(() -> {

                fireContentsChanged();

            });

            return;

        }

        this.fireContentsChanged(this, 0, this.filteredElements.size());

    }

    @Override

    public String getFilter() {

        return this.filter;

    }

    @Override

    public void sort(final boolean ascending) {

        this.sortBackground(ascending);

    }

    private synchronized void sortBackground(final boolean ascending) {

        if (this.th != null) {

            this.th.cancelRequest();

        }

        this.th = new AbstractCancellableTask("FilteredListModelSorter") {

            @Override

            public void run() {

                final List items = new ListModelToListAdapter(elements);

                items.sort((Object o1, Object o2) -> {

                    if (o1 instanceof LabeledValue) {

                        o1 = ((LabeledValue) o1).getLabel();

                    }

                    if (o2 instanceof LabeledValue) {

                        o2 = ((LabeledValue) o2).getLabel();

                    }

                    String o1string = Objects.toString(o1, "");

                    String o2string = Objects.toString(o2, "");

                    if (!isCaseSensitive()) {

                        o1string = o1string.toLowerCase();

                        o2string = o2string.toLowerCase();

                    }

                    int r = ObjectUtils.compare(o1string, o2string);

                    if (ascending) {

                        return r;

                    }

                    return -r;

                });

                if (this.isCancellationRequested()) {

                    return;

                }

                copy(elements, filteredElements, filter);

                fireContentsChanged();

            }

        };

        th.start();

    }

    @Override

    public void setCaseSensitive(boolean sensitive) {

        this.caseSensitive = sensitive;

    }

    @Override

    public boolean isCaseSensitive() {

        return this.caseSensitive;

    }

}