Changeset 6678

Timestamp:

10/13/15 15:07:57 (9 years ago)

Author:

Twan Goosen

Message:

"Show all" link for collections with more than 50 children
Refs #805

Location:

vlo/branches/vlo-3.3/vlo-web-app/src/main/java/eu/clarin/cmdi/vlo/wicket

Files:

• components/AjaxFallbackLinkLabel.html (added)
• components/AjaxFallbackLinkLabel.java (added)
• panels/record/HierarchyPanel.html (modified) (1 diff)
• panels/record/HierarchyPanel.java (modified) (9 diffs)

vlo/branches/vlo-3.3/vlo-web-app/src/main/java/eu/clarin/cmdi/vlo/wicket/panels/record/HierarchyPanel.html

@@ -38 +38 @@
                 <a wicket:id="showAll">Show all... (<span wicket:id="itemCount">999</span>)</a>
             </div>
-            <div id="tree" wicket:id="tree">[TREE]</div>
+            <div wicket:id="treeContainer">
+                <div id="tree" wicket:id="tree">[TREE]</div>
+            </div>
         </wicket:panel>
     </body>

vlo/branches/vlo-3.3/vlo-web-app/src/main/java/eu/clarin/cmdi/vlo/wicket/panels/record/HierarchyPanel.java

@@ -21 +21 @@
 import eu.clarin.cmdi.vlo.FacetConstants;
 import eu.clarin.cmdi.vlo.service.solr.SolrDocumentService;
+import eu.clarin.cmdi.vlo.wicket.components.AjaxFallbackLinkLabel;
 import eu.clarin.cmdi.vlo.wicket.components.IndicatingNestedTree;
 import eu.clarin.cmdi.vlo.wicket.components.NamedRecordPageLink;
 import eu.clarin.cmdi.vlo.wicket.model.SolrDocumentModel;
+import java.io.Serializable;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.Objects;
 import org.apache.solr.common.SolrDocument;
 import org.apache.wicket.Component;
+import org.apache.wicket.MarkupContainer;
 import org.apache.wicket.ajax.AjaxRequestTarget;
 import org.apache.wicket.behavior.AttributeAppender;
@@ -58 +62 @@
      */
     public static final int INITIAL_PARENTS_SHOWN = 5;
+    public static final int INITIAL_CHILRDEN_SHOWN = 50;
 
     @SpringBean
@@ -63 +68 @@
 
     private final IDataProvider<SolrDocument> parentsProvider;
-    private final AbstractTree<SolrDocument> tree;
+    private final MarkupContainer treeContainer;
+    private final AbstractTree<ModelWrapper<SolrDocument>> tree;
     private final IModel<SolrDocument> pageDocumentModel;
 
@@ -75 +81 @@
 
         tree = createTree("tree");
-        add(tree);
+
+        treeContainer = new WebMarkupContainer("treeContainer");
+        treeContainer.setOutputMarkupId(true);
+        treeContainer.add(tree);
+        add(treeContainer);
 
         setOutputMarkupId(true);
@@ -97 +107 @@
                         // tree root up one level, expand root for traceability by user
                         HierarchyPanel.this.setModel(item.getModel());
-                        tree.expand(item.getModelObject());
+                        tree.expand(new ModelWrapper<>(item.getModel()));
                         if (target != null) {
                             target.add(HierarchyPanel.this);
@@ -103 +113 @@
                     }
                 });
-                
+
                 item.add(new Behavior() {
 
@@ -148 +158 @@
     }
 
-    private AbstractTree<SolrDocument> createTree(String id) {
-        final AbstractTree<SolrDocument> result = new IndicatingNestedTree<SolrDocument>(id, new HierarchyTreeProvider()) {
-
-            @Override
-            protected Component newContentComponent(String id, final IModel<SolrDocument> node) {
-                return new NamedRecordPageLink(id, node) {
-
-                    @Override
-                    protected void onConfigure() {
-                        setEnabled(!node.equals(pageDocumentModel));
-                    }
-                };
+    private AbstractTree createTree(String id) {
+        final HierarchyTreeProvider treeProvider = new HierarchyTreeProvider();
+        final AbstractTree<ModelWrapper<SolrDocument>> result = new IndicatingNestedTree<ModelWrapper<SolrDocument>>(id, treeProvider) {
+
+            @Override
+            protected Component newContentComponent(String id, final IModel<ModelWrapper<SolrDocument>> node) {
+                if (node.getObject().isLimit()) {
+                    return new AjaxFallbackLinkLabel(id, node, Model.of("Show all... (" + node.getObject().getCount() + ")")) {
+
+                        @Override
+                        public void onClick(AjaxRequestTarget target) {
+                            treeProvider.setChildrenShown(null);
+                            target.add(treeContainer);
+                        }
+
+                    };
+                } else {
+                    return new NamedRecordPageLink(id, node.getObject().getModel()) {
+
+                        @Override
+                        protected void onConfigure() {
+                            setEnabled(!node.equals(pageDocumentModel));
+                        }
+                    };
+                }
             }
 
@@ -184 +207 @@
     }
 
-    private class HierarchyTreeProvider extends SortableTreeProvider<SolrDocument, Object> {
-
-        @Override
-        public Iterator<? extends SolrDocument> getRoots() {
-            return Iterators.singletonIterator(HierarchyPanel.this.getModel().getObject());
-        }
-
-        @Override
-        public boolean hasChildren(SolrDocument node) {
-            Object partCount = node.getFieldValue(FacetConstants.FIELD_HAS_PART_COUNT);
-            return (partCount instanceof Number) && ((Number) partCount).intValue() > 0;
-        }
-
-        @Override
-        public Iterator<? extends SolrDocument> getChildren(SolrDocument node) {
-            final Collection<Object> parts = node.getFieldValues(FacetConstants.FIELD_HAS_PART);
-            return Iterators.transform(parts.iterator(), new Function<Object, SolrDocument>() {
-
-                @Override
-                public SolrDocument apply(Object childId) {
-                    return documentService.getDocument(childId.toString());
-                }
-            });
-        }
-
-        @Override
-        public IModel<SolrDocument> model(SolrDocument object) {
-            return new SolrDocumentModel(object);
+    private class HierarchyTreeProvider extends SortableTreeProvider<ModelWrapper<SolrDocument>, Object> {
+
+        private Integer childrenShown = INITIAL_CHILRDEN_SHOWN;
+
+        public void setChildrenShown(Integer childrenShown) {
+            this.childrenShown = childrenShown;
+        }
+
+        @Override
+        public Iterator<? extends ModelWrapper<SolrDocument>> getRoots() {
+            return Iterators.singletonIterator(
+                    new ModelWrapper<>(
+                            HierarchyPanel.this.getModel()));
+        }
+
+        @Override
+        public boolean hasChildren(ModelWrapper<SolrDocument> node) {
+            if (node.isLimit()) {
+                return false;
+            } else {
+                final Object partCount = node.getModelObject().getFieldValue(FacetConstants.FIELD_HAS_PART_COUNT);
+                return (partCount instanceof Number) && ((Number) partCount).intValue() > 0;
+            }
+        }
+
+        @Override
+        public Iterator<? extends ModelWrapper<SolrDocument>> getChildren(ModelWrapper<SolrDocument> node) {
+            if (node.isLimit()) {
+                return Collections.emptyIterator();
+            } else {
+                final Collection<Object> parts = node.getModelObject().getFieldValues(FacetConstants.FIELD_HAS_PART);
+                final Iterator<Object> objectIterator;
+                if (childrenShown == null) {
+                    // unlimited
+                    objectIterator = parts.iterator();
+                } else {
+                    objectIterator = Iterators.limit(parts.iterator(), childrenShown);
+                }
+                final Iterator<ModelWrapper<SolrDocument>> iterator = Iterators.transform(objectIterator, new Function<Object, ModelWrapper<SolrDocument>>() {
+
+                    @Override
+                    public ModelWrapper<SolrDocument> apply(Object childId) {
+                        final SolrDocument document = documentService.getDocument(childId.toString());
+                        return new ModelWrapper<>(new SolrDocumentModel(document));
+                    }
+                });
+                if (childrenShown != null && parts.size() > childrenShown) {
+                    return Iterators.concat(iterator, // add empty model wrapper to indicate "end of page"
+                            Iterators.singletonIterator(new ModelWrapper<SolrDocument>(parts.size())));
+                } else {
+                    return iterator;
+                }
+            }
+        }
+
+        @Override
+        public IModel<ModelWrapper<SolrDocument>> model(ModelWrapper<SolrDocument> object) {
+            return object;
         }
     }
@@ -269 +322 @@
     }
 
+    private class ModelWrapper<T> extends AbstractReadOnlyModel<ModelWrapper<T>> implements Serializable {
+
+        /**
+         * Limit reached? TODO: add count
+         */
+        private final boolean limit;
+
+        /**
+         * Total number of items (if beyond the limit)
+         */
+        private final int count;
+
+        /**
+         * Inner model
+         */
+        private final IModel<T> model;
+
+        public ModelWrapper(int count) {
+            this.limit = true;
+            this.count = count;
+            this.model = null;
+        }
+
+        public ModelWrapper(IModel<T> model) {
+            this.limit = false;
+            this.count = -1;
+            this.model = model;
+        }
+
+        public boolean isLimit() {
+            return limit;
+        }
+
+        public IModel<T> getModel() {
+            return model;
+        }
+
+        public int getCount() {
+            return count;
+        }
+
+        public T getModelObject() {
+            if (model == null) {
+                return null;
+            } else {
+                return model.getObject();
+            }
+        }
+
+        // as IModel<T>
+        @Override
+        public void detach() {
+            if (model != null) {
+                model.detach();
+            }
+        }
+
+        // as IModel<T>
+        @Override
+        public ModelWrapper<T> getObject() {
+            return this;
+        }
+
+        @Override
+        public int hashCode() {
+            int hash = 5;
+            hash = 41 * hash + (this.limit ? 1 : 0);
+            hash = 41 * hash + Objects.hashCode(this.model);
+            return hash;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (getClass() != obj.getClass()) {
+                return false;
+            }
+            final ModelWrapper<?> other = (ModelWrapper<?>) obj;
+            if (this.limit != other.limit) {
+                return false;
+            }
+            if (!Objects.equals(this.model, other.model)) {
+                return false;
+            }
+            return true;
+        }
+
+    }
+
 }