CharmListView Infinite Scroll

I need basically an event that triggers at each 200 records loaded, so more data can be loaded until the end of data.

I tried to extend CharmListCell and using the method updateItem like this:

@Override
public void updateItem(Model item, boolean empty) {
    super.updateItem(item, empty);
    currentItem = item;
    if (!empty && item != null) {
        update();
        setGraphic(slidingTile);
    } else {
        setGraphic(null);
    }

    System.out.println(getIndex());
}

But the System.out.println(getIndex()); method returns -1;

I would like to call my backend method when the scroll down gets the end of last fetched block and so on, until get the end of data like the "infinite scroll" technique.

Thanks!

The CharmListCell doesn't expose the index of the underlying listView, but even if it did, that wouldn't be of much help to find out if you are scrolling over the end of the current list or not.

I'd suggest a different approach, which is also valid for a regular ListView, with the advantage of having the CharmListView features (mainly headers and the refresh indicator).

This short sample, created with a single view project using the Gluon IDE plugin and Charm 5.0.0, shows how to create a CharmListView control, and fill it with 30 items at a time. I haven't provided a factory cell, nor the headers, and for the sake of simplicity I'm just adding consecutive integers.

With a lookup, and after the view is shown (so the listView is added to the scene) we find the vertical ScrollBar of the listView, and then we add a listener to track its position. When it gets closer to 1, we simulate the load of another batch of items, with a pause transition that represents a heavy task.

Note the use of the refresh indicator. When new data is added, we scroll back to the first of the new items, so we can keep scrolling again.

public class BasicView extends View {

    private final ObservableList<Integer> data;
    private CharmListView<Integer, Integer> listView;
    private final int batchSize = 30;
    private PauseTransition pause;

    public BasicView() {
        data = FXCollections.observableArrayList();

        listView = new CharmListView<>(data);
        setOnShown(e -> {
            ScrollBar scrollBar = null;
            for (Node bar : listView.lookupAll(".scroll-bar")) {
                if (bar instanceof ScrollBar && ((ScrollBar) bar).getOrientation().equals(Orientation.VERTICAL)) {
                    scrollBar = (ScrollBar) bar;
                    break;
                }
            }
            if (scrollBar != null) {
                scrollBar.valueProperty().addListener((obs, ov, nv) -> {
                    if (nv.doubleValue() > 0.95) {
                        addBatch();
                    }
                });
                addBatch();
            }
        });
        setCenter(new VBox(listView));
    }

    private void addBatch() {
        listView.setRefreshIndicatorVisible(true);
        if (pause == null) {
            pause = new PauseTransition(Duration.seconds(1));
            pause.setOnFinished(f -> {
                int size = data.size();
                List<Integer> list = new ArrayList<>();
                for (int i = size; i < size + batchSize; i++) {
                    list.add(i);
                }
                data.addAll(list);
                listView.scrollTo(list.get(0));
                listView.setRefreshIndicatorVisible(false);
            });
        } else {
            pause.stop();
        }
        pause.playFromStart();
    }
}

Note also that you could benefit from the setOnPullToRefresh() method, at any time. For instance, if you add this:

listView.setOnPullToRefresh(e -> addBatch());

whenever you go to the top of the list and drag it down (on a mobile device), it will make another call to load a new batch of items. Obviously, this is the opposite behavior as the "infinite scrolling", but it is possible as well with the CharmListView control.