WebSVN - OpenConcerto - Diff - Rev 147 and 150 - /trunk/Modules/Module Operation/src/org/openconcerto/modules/operation/CheckListModel.java

 package org.openconcerto.modules.operation;
 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 javax.swing.AbstractListModel;
 import javax.swing.SwingUtilities;
 import javax.swing.SwingWorker;
 import org.openconcerto.ui.list.CheckListItem;
+import net.jcip.annotations.GuardedBy;
-public abstract class CheckListModel extends AbstractListModel {
+public abstract class CheckListModel<T> extends AbstractListModel<CheckListItem> {
+    private final Class<T> itemClass;
     private List<CheckListItem> items = new ArrayList<CheckListItem>();
+    // don't do multiple loads concurrently, allow to know if an update is coming
+    @GuardedBy("EDT")
+    private SwingWorker<?, ?> loadWorker;
+    // needed so that we can store wantedCheckedKeys before the first fill
+    @GuardedBy("EDT")
+    private boolean neverFilled = true;
+    // keys are needed since other classes might not be able to create instances of T
+    // e.g. the key is an Integer ID and T is an SQLRow
+    @GuardedBy("EDT")
+    private Set<Object> wantedCheckedKeys;
+    public CheckListModel(final Class<T> clazz) {
+        this.itemClass = clazz;
+    }
+    public final Class<T> getItemClass() {
+        return this.itemClass;
+    }
+    private final List<CheckListItem> getItems() {
+        assert SwingUtilities.isEventDispatchThread();
+        return this.items;
+    }
     @Override
     public int getSize() {
-        return items.size();
+        return getItems().size();
+    }
     @Override
-    public Object getElementAt(int index) {
+    public CheckListItem getElementAt(int index) {
-        return items.get(index);
+        return getItems().get(index);
+    }
     public void loadContent() {
         assert SwingUtilities.isEventDispatchThread();
+        if (this.loadWorker != null) {
+            this.loadWorker.cancel(true);
+        }
-        SwingWorker<List<CheckListItem>, Object> worker = new SwingWorker<List<CheckListItem>, Object>() {
+        this.loadWorker = new SwingWorker<List<CheckListItem>, Object>() {
             @Override
             protected List<CheckListItem> doInBackground() throws Exception {
                 return loadItems();
+            }
             @Override
             protected void done() {
+                // if cancel() is called after doInBackground() nothing happens
+                // but updating is set to a new instance
+                if (this.isCancelled() || CheckListModel.this.loadWorker != this) {
+                    // une autre maj arrive
+                    return;
+                }
                 try {
                     final List<CheckListItem> l = get();
+                    final Collection<Object> wantedKeys = getWantedCheckedKeys(true);
+                    final boolean checkAll = items.isEmpty() && wantedKeys == null;
-                    if (items.isEmpty()) {
+                    if (checkAll) {
                         // On ajoute tout, et on sélectionne tout
-                        items.clear();
                         items.addAll(l);
                         for (CheckListItem item : items) {
                             item.setSelected(true);
+                        }
                     } else {
-                        List<Object> previouslySelectedObject = new ArrayList<Object>();
+                        final Collection<Object> toCheck = wantedKeys == null ? getCheckedKeys() : wantedKeys;
-                        for (CheckListItem item : items) {
-                            if (item.isSelected()) {
-                                previouslySelectedObject.add(item.getObject());
-                            }
-                        }
                         items.clear();
                         items.addAll(l);
                         // restaure la sélection
-                        for (CheckListItem item : items) {
-                            final boolean wasSelected = previouslySelectedObject.contains(item.getObject());
-                            item.setSelected(wasSelected);
+                        _setCheckedKeys(toCheck);
-                        }
+                    }
+                    CheckListModel.this.neverFilled = false;
+                    CheckListModel.this.wantedCheckedKeys = null;
-                    refresh();
+                    fireContentsChanged();
                 } catch (Exception e) {
                     e.printStackTrace();
+                } finally {
+                    assert CheckListModel.this.loadWorker == this;
+                    CheckListModel.this.loadWorker = null;
+                }
+            }
         };
-        worker.execute();
+        this.loadWorker.execute();
+    }
     public abstract List<CheckListItem> loadItems();
-    public void refresh() {
+    protected final void fireContentsChanged() {
-        fireContentsChanged(this, 0, items.size());
+        fireContentsChanged(this, 0, getSize() - 1);
+    }
+    public final List<CheckListItem> getCheckedItems() {
+        final List<CheckListItem> result = new ArrayList<CheckListItem>();
+        final int size = this.getSize();
+        for (int i = 0; i < size; i++) {
+            final CheckListItem item = this.getElementAt(i);
+            if (item.isSelected()) {
+                result.add(item);
+            }
+        }
+        return result;
+    }
+    public final List<T> getCheckedObjects() {
+        final List<CheckListItem> checkedItems = this.getCheckedItems();
+        final int size = checkedItems.size();
+        final List<T> result = new ArrayList<T>(size);
+        for (int i = 0; i < size; i++) {
+            result.add(this.itemClass.cast(checkedItems.get(i).getObject()));
+        }
+        return result;
+    }
+    public final List<Object> getCheckedKeys() {
+        final List<CheckListItem> checkedItems = this.getCheckedItems();
+        final int size = checkedItems.size();
+        final List<Object> result = new ArrayList<Object>(size);
+        for (int i = 0; i < size; i++) {
+            result.add(checkedItems.get(i).getKey());
+        }
+        return result;
+    }
+    public final Collection<Object> getWantedCheckedKeys(final boolean allowNull) {
+        if (allowNull || this.wantedCheckedKeys != null)
+            return this.wantedCheckedKeys;
+        return this.getCheckedKeys();
+    }
+    public final void setCheckedKeys(final Collection<?> sel) {
+        if (this.loadWorker != null || this.neverFilled) {
+            this.wantedCheckedKeys = Collections.unmodifiableSet(new HashSet<>(sel));
+        } else {
+            _setCheckedKeys(sel);
+        }
+    }
+    private final void _setCheckedKeys(final Collection<?> sel) {
+        for (CheckListItem item : this.getItems()) {
+            item.setSelected(sel.contains(item.getKey()));
+        }
+    }
+    public final void invertCheckAt(final int index) {
+        final CheckListItem item = this.items.get(index);
+        item.setSelected(!item.isSelected());
+        fireContentsChanged(this, index, index);
+    }
+    public final void checkAllAs(final int index) {
+        final boolean newVal = this.items.get(index).isSelected();
+        for (final CheckListItem i : this.items) {
+            i.setSelected(newVal);
+        }
+        fireContentsChanged();
+    }
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + " of " + this.getItemClass();
+    }
+}

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/Modules/Module Operation/src/org/openconcerto/modules/operation/CheckListModel.java @ 147 - Rev 147 → 150