Example usage for org.apache.wicket.markup.repeater RefreshingView setItemReuseStrategy

Introduction

In this page you can find the example usage for org.apache.wicket.markup.repeater RefreshingView setItemReuseStrategy.

Prototype

public RefreshingView<T> setItemReuseStrategy(IItemReuseStrategy strategy) 

Source Link

Document

Sets the item reuse strategy.

Usage

From source file:de.alpharogroup.wicket.components.listview.RefreshingViewPanel.java

License:Apache License

/**
 * Factory method for creating a new {@link RefreshingView}. This method is invoked in the
 * constructor from the derived classes and can be overridden so users can provide their own
 * version of the new {@link RefreshingView}.
 *
 * @param id//from w ww.  jav a 2s.c  om
 *            the id
 * @param model
 *            the model
 * @return the new {@link RefreshingView}.
 */
protected RefreshingView<T> newRefreshingView(final String id, final IModel<List<T>> model) {
    final RefreshingView<T> listView = new RefreshingView<T>(id, model) {
        /** The Constant serialVersionUID. */
        private static final long serialVersionUID = 1L;

        /**
         * {@inheritDoc}
         */
        @Override
        protected Iterator<IModel<T>> getItemModels() {
            return new ModelIteratorAdapter<T>(getModelObject().iterator()) {

                /**
                 * {@inheritDoc}
                 */
                @Override
                protected IModel<T> model(final T object) {
                    return Model.of(object);
                }
            };
        }

        /**
         * {@inheritDoc}
         */
        @Override
        protected Item<T> newItem(final String id, final int index, final IModel<T> model) {
            return RefreshingViewPanel.this.newItem(id, index, model);
        }

        /**
         * {@inheritDoc}
         */
        @Override
        protected void populateItem(final Item<T> item) {
            item.add(newListComponent("item", item));
        }

    };
    listView.setItemReuseStrategy(ReuseIfModelsEqualStrategy.getInstance());
    return listView;
}

---

From source file:de.alpharogroup.wicket.data.provider.examples.refreshingview.RefreshingViewPanel.java

License:Apache License

public RefreshingViewPanel(final String id, final IModel<?> model) {
    super(id, model);

    form = new Form<Person>("form");
    add(form);/*from ww  w  .  j  ava2  s .c o m*/

    // create a repeater that will display the list of contacts.
    final RefreshingView<Person> refreshingView = new RefreshingView<Person>("simple") {
        /**
         * The serialVersionUID.
         */
        private static final long serialVersionUID = 1L;

        @Override
        protected Iterator<IModel<Person>> getItemModels() {
            // for simplicity we only show the first 10 contacts
            // SortParam<String> sort = new SortParam<String>("firstname",
            // true);
            final Iterator<Person> contacts = PersonDatabaseManager.getInstance().getPersons().iterator();

            // the iterator returns contact objects, but we need it to
            // return models, we use this handy adapter class to perform
            // on-the-fly conversion.
            return new ModelIteratorAdapter<Person>(contacts) {
                @Override
                protected IModel<Person> model(final Person object) {
                    return new CompoundPropertyModel<Person>(object);
                }
            };
        }

        @Override
        protected Item<Person> newItem(final String id, final int index, final IModel<Person> model) {
            // this item sets markup class attribute to either 'odd' or
            // 'even' for decoration
            return new OddEvenItem<Person>(id, index, model);
        }

        @Override
        protected void populateItem(final Item<Person> item) {
            // populate the row of the repeater
            final IModel<Person> contact = item.getModel();
            item.add(new ActionPanel("actions", contact));
            item.add(new TextField<String>("firstname"));
            item.add(new TextField<String>("lastname"));
        }
    };

    // because we are in a form we need to preserve state of the component
    // hierarchy (because it might contain things like form errors that
    // would be lost if the hierarchy for each item was recreated every
    // request by default), so we use an item reuse strategy.
    refreshingView.setItemReuseStrategy(ReuseIfModelsEqualStrategy.getInstance());

    form.add(refreshingView);
}

---

From source file:org.efaps.ui.wicket.components.tree.SubElement.java

License:Apache License

/**
 * @param _wicketId wicket id for this component
 * @param _tree Nested tree element/*from  ww w .  j  a  va 2s .co m*/
 * @param _model model for this component
 */
public SubElement(final String _wicketId, final NestedTree<UIStructurBrowser> _tree,
        final IModel<UIStructurBrowser> _model) {
    super(_wicketId, _model);

    if (_tree == null) {
        throw new IllegalArgumentException("argument [tree] cannot be null");
    }
    this.tree = _tree;

    final RefreshingView<UIStructurBrowser> branches = new RefreshingView<UIStructurBrowser>("branches") {

        private static final long serialVersionUID = 1L;

        @Override
        protected Iterator<IModel<UIStructurBrowser>> getItemModels() {
            return new ModelIterator();
        }

        @Override
        protected Item<UIStructurBrowser> newItem(final String _wicketId, final int _index,
                final IModel<UIStructurBrowser> _model) {
            return newBranchItem(_wicketId, _index, _model);
        }

        @Override
        protected void populateItem(final Item<UIStructurBrowser> _item) {
            try {
                populateBranch(_item);
            } catch (final EFapsException e) {
                SubElement.LOG.error("EFapsException", e);
            }
        }
    };
    branches.setItemReuseStrategy(new IItemReuseStrategy() {

        private static final long serialVersionUID = 1L;

        @Override
        public <S> Iterator<Item<S>> getItems(final IItemFactory<S> _factory,
                final Iterator<IModel<S>> _newModels, final Iterator<Item<S>> _existingItems) {
            return SubElement.this.tree.getItemReuseStrategy().getItems(_factory, _newModels, _existingItems);
        }
    });
    add(branches);
}

---

From source file:org.jaulp.wicket.data.provider.examples.refreshingview.RefreshingViewPanel.java

License:Apache License

public RefreshingViewPanel(String id, IModel<?> model) {
    super(id, model);

    form = new Form<Person>("form");
    add(form);/* ww  w.  j a va 2 s.  com*/

    // create a repeater that will display the list of contacts.
    RefreshingView<Person> refreshingView = new RefreshingView<Person>("simple") {
        /**
         * The serialVersionUID.
         */
        private static final long serialVersionUID = 1L;

        @Override
        protected Iterator<IModel<Person>> getItemModels() {
            // for simplicity we only show the first 10 contacts
            // SortParam<String> sort = new SortParam<String>("firstname",
            // true);
            Iterator<Person> contacts = getPersons().iterator();

            // the iterator returns contact objects, but we need it to
            // return models, we use this handy adapter class to perform
            // on-the-fly conversion.
            return new ModelIteratorAdapter<Person>(contacts) {
                @Override
                protected IModel<Person> model(Person object) {
                    return new CompoundPropertyModel<Person>(object);
                }
            };
        }

        @Override
        protected void populateItem(final Item<Person> item) {
            // populate the row of the repeater
            IModel<Person> contact = item.getModel();
            item.add(new ActionPanel("actions", contact));
            item.add(new TextField<String>("firstname"));
            item.add(new TextField<String>("lastname"));
        }

        @Override
        protected Item<Person> newItem(String id, int index, IModel<Person> model) {
            // this item sets markup class attribute to either 'odd' or
            // 'even' for decoration
            return new OddEvenItem<Person>(id, index, model);
        }
    };

    // because we are in a form we need to preserve state of the component
    // hierarchy (because it might contain things like form errors that
    // would be lost if the hierarchy for each item was recreated every
    // request by default), so we use an item reuse strategy.
    refreshingView.setItemReuseStrategy(ReuseIfModelsEqualStrategy.getInstance());

    form.add(refreshingView);
}

---

From source file:wickettree.nested.Subtree.java

License:Apache License

/**
 * Create a subtree for the children of the node contained in the given
 * model or the root nodes if the model contains <code>null</code>.
 * //from  w ww  . jav  a2  s.c o m
 * @param id
 *            component id
 * @param tree
 *            the containing tree
 * @param model
 */
public Subtree(String id, final NestedTree<T> tree, final IModel<T> model) {
    super(id, model);

    if (tree == null) {
        throw new IllegalArgumentException("argument [tree] cannot be null");
    }
    this.tree = tree;

    RefreshingView<T> branches = new RefreshingView<T>("branches") {
        private static final long serialVersionUID = 1L;

        @Override
        protected Iterator<IModel<T>> getItemModels() {
            return new ModelIterator();
        }

        @Override
        protected Item<T> newItem(String id, int index, IModel<T> model) {
            return newBranchItem(id, index, model);
        }

        @Override
        protected void populateItem(Item<T> item) {
            IModel<T> model = item.getModel();

            Component node = tree.newNodeComponent("node", model);
            item.add(node);

            item.add(tree.newSubtree("subtree", model));
        }
    };
    branches.setItemReuseStrategy(new IItemReuseStrategy() {
        private static final long serialVersionUID = 1L;

        public <S> Iterator<Item<S>> getItems(IItemFactory<S> factory, Iterator<IModel<S>> newModels,
                Iterator<Item<S>> existingItems) {
            return tree.getItemReuseStrategy().getItems(factory, newModels, existingItems);
        }
    });
    add(branches);
}

---