Nebula 分页的动态页面大小更改导致 IllegalArgumentException

Question

我使用 Eclipse Nebula 分页 API。

• 我有一个小示例表，有 9 行，页面大小为 2。

• 我显示最后一页 5/5。

• 然后我尝试将页面大小从 2 更改为 10（使用自定义输入字段）。

PageListHelper 然后尝试获取 fromIndex = 10 和 toIndex = 9 的子列表，从而导致异常。

List<?> content = list.subList(fromIndex, toIndex);

我猜是缺少对 fromIndex 的检查，例如

if (fromIndex > totalSize) {
  return emptyPageResult;
}

https://github.com/eclipse/nebula/blob/34a465c057ca960e9b9c71eb6cbc15d213304b7a/widgets/pagination/org.eclipse.nebula.widgets.pagination/src/org/eclipse/nebula/widgets/pagination/collections/PageListHelper.java

在更改页面大小之前，我尝试将当前页面重置为 1。 但这并没有帮助。

=> 是否允许动态更改页面大小？有人知道解决方法吗？

编辑

我提交了一个错误： https://bugs.eclipse.org/bugs/show_bug.cgi?id=511673

Answer 1

我创建了一个自定义 PageResultLoader，其中包括对 fromIndex 的检查：

package org.treez.data.table.nebula.nat;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.nebula.widgets.pagination.IPageLoader;
import org.eclipse.nebula.widgets.pagination.PageableController;
import org.eclipse.nebula.widgets.pagination.collections.DefaultSortProcessor;
import org.eclipse.nebula.widgets.pagination.collections.PageResult;
import org.eclipse.nebula.widgets.pagination.collections.SortProcessor;
import org.eclipse.swt.SWT;
import org.treez.core.data.row.Row;

public class PageResultLoader implements IPageLoader<PageResult<Row>> {

private List<Row> items;

public PageResultLoader(List<Row> items) {
    this.items = items;
}

public void setItems(List<Row> items) {
    this.items = items;
}

public List<Row> getItems() {
    return items;
}

@Override
public PageResult<Row> loadPage(PageableController controller) {

    SortProcessor processor = DefaultSortProcessor.getInstance();
    int sortDirection = controller.getSortDirection();
    if (sortDirection != SWT.NONE) {
        // Sort the list
        processor.sort(items, controller.getSortPropertyName(), sortDirection);
    }
    int totalSize = items.size();
    int pageSize = controller.getPageSize();
    int pageIndex = controller.getPageOffset();

    int fromIndex = pageIndex;
    if (fromIndex > totalSize) {
        return new PageResult<Row>(new ArrayList<Row>(), totalSize);
    }

    int toIndex = pageIndex + pageSize;
    if (toIndex > totalSize) {
        toIndex = totalSize;
    }
    List<Row> content = items.subList(fromIndex, toIndex);
    return new PageResult<Row>(content, totalSize);
}

}

如果其他人也想动态设置页面大小，我的分页组件渲染器可以作为起点：

public class PaginationComponentRenderer extends AbstractPageControllerComposite {

//#region ATTRIBUTES

private Label resultLabel;

private Label first;

private Label previous;

private Text currentPageIndexField;

private Label totalPagesLabel;

private Label next;

private Label last;

private Text pageSizeField;

private final int maxPageSize = 1000000;

//#end region

//#region CONSTRUCTORS

public PaginationComponentRenderer(Composite parent, int style, PageableController controller) {
    super(parent, style, controller);
    refreshEnabled(controller);
}

//#end region

//#region METHODS

@Override
protected void createUI(Composite parent) {

    GridLayout parentLayout = new GridLayout(1, false);
    parentLayout.verticalSpacing = 0;
    parentLayout.marginTop = 0;
    parentLayout.marginBottom = 0;
    parent.setLayout(parentLayout);

    GridLayout layout = new GridLayout(1, false);
    layout.verticalSpacing = 0;
    layout.marginTop = 0;
    layout.marginBottom = 0;
    this.setLayout(layout);

    createButtonsAndInputFields(parent);

    createRowLimitForPagesField(parent);
}

@SuppressWarnings("checkstyle:magicnumber")
private void createButtonsAndInputFields(Composite parent) {

    FormToolkit toolkit = new FormToolkit(Display.getCurrent());
    PageableController controller = getController();

    Composite rowContainer = toolkit.createComposite(parent);

    GridLayout layout = new GridLayout(8, false);
    layout.verticalSpacing = 0;
    layout.marginTop = 0;
    layout.marginBottom = 0;
    rowContainer.setLayout(layout);
    rowContainer.setLayoutData(new GridData(SWT.FILL, SWT.NONE, true, false));

    createRowsLabel(toolkit, rowContainer);

    toolkit.createLabel(rowContainer, "     Page ");

    createFirstButton(toolkit, rowContainer, controller);
    createPreviousButton(toolkit, rowContainer, controller);

    createCurrentPageField(toolkit, rowContainer);

    crateNextButton(toolkit, rowContainer, controller);
    createLastButton(toolkit, rowContainer, controller);

    createMaxPageLabel(toolkit, rowContainer, controller);

}

private void createFirstButton(FormToolkit toolkit, Composite container, PageableController controller) {

    first = toolkit.createLabel(container, "", SWT.NONE);
    first.setImage(Activator.getImage("first"));
    first.addListener(SWT.MouseDown, (e) -> {
        controller.setCurrentPage(0);
    });
}

private void createPreviousButton(FormToolkit toolkit, Composite container, PageableController controller) {
    previous = toolkit.createLabel(container, "", SWT.NONE);
    previous.setImage(Activator.getImage("previous"));
    previous.addListener(SWT.MouseDown, (e) -> {
        controller.setCurrentPage(controller.getCurrentPage() - 1);
    });
}

@SuppressWarnings("checkstyle:magicnumber")
private void createCurrentPageField(FormToolkit toolkit, Composite container) {
    currentPageIndexField = toolkit.createText(container, "1", SWT.NONE);
    currentPageIndexField.setLayoutData(new GridData(40, 15));
    currentPageIndexField.setToolTipText("Page index");
    currentPageIndexField.addTraverseListener((e) -> updateCurrentPageIndex());
    currentPageIndexField.addFocusListener(new FocusListener() {

        @Override
        public void focusLost(FocusEvent e) {
            updateCurrentPageIndex();
        }

        @Override
        public void focusGained(FocusEvent e) {

        }

    });

}

private void updateCurrentPageIndex() {
    PageableController controller = getController();
    int pageNumberStartingWithOne = getValidPageIndex();
    controller.setCurrentPage(pageNumberStartingWithOne - 1);
    currentPageIndexField.setText("" + pageNumberStartingWithOne);
}

private void createMaxPageLabel(FormToolkit toolkit, Composite parent, PageableController controller) {
    Composite container = toolkit.createComposite(parent);
    GridLayout layout = new GridLayout(2, false);
    layout.verticalSpacing = 0;
    layout.marginTop = 0;
    layout.marginBottom = 0;
    container.setLayout(layout);

    toolkit.createLabel(container, "of");
    totalPagesLabel = toolkit.createLabel(container, "" + controller.getTotalPages());
}

private void crateNextButton(FormToolkit toolkit, Composite container, PageableController controller) {
    next = toolkit.createLabel(container, "", SWT.NONE);
    next.setImage(Activator.getImage("next"));
    next.addListener(SWT.MouseDown, (e) -> {
        controller.setCurrentPage(controller.getCurrentPage() + 1);
    });
}

private void createLastButton(FormToolkit toolkit, Composite container, PageableController controller) {
    last = toolkit.createLabel(container, "", SWT.NONE);
    last.setImage(Activator.getImage("last"));
    last.addListener(SWT.MouseDown, (e) -> {
        controller.setCurrentPage(controller.getTotalPages() - 1);
    });
}

private void createRowsLabel(FormToolkit toolkit, Composite parent) {
    resultLabel = toolkit.createLabel(parent, ""); //also see method getResultsText
}

@SuppressWarnings("checkstyle:magicnumber")
private void createRowLimitForPagesField(Composite parent) {

    FormToolkit toolkit = new FormToolkit(Display.getCurrent());
    PageableController controller = getController();

    Composite container = toolkit.createComposite(parent);
    GridLayout layout = new GridLayout(3, false);
    layout.verticalSpacing = 0;
    layout.marginTop = 0;
    layout.marginBottom = 0;

    container.setLayout(layout);
    GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, false);
    container.setLayoutData(gridData);

    //createSpacer(toolkit, container);

    toolkit.createLabel(container, "Max rows per page: ");

    pageSizeField = toolkit.createText(container, "" + controller.getPageSize(), SWT.NONE);
    pageSizeField.setToolTipText("Maximum number of rows per page");

    pageSizeField.setLayoutData(new GridData(40, 15));

    pageSizeField.addTraverseListener((e) -> upatePageSize());
    pageSizeField.addFocusListener(new FocusListener() {

        @Override
        public void focusLost(FocusEvent e) {
            upatePageSize();
        }

        @Override
        public void focusGained(FocusEvent arg0) {}

    });
}

private void upatePageSize() {
    PageableController controller = getController();
    int pageSize = getValidPageSize();
    pageSizeField.setText("" + pageSize);
    controller.setPageSize(pageSize);

    updateCurrentPageIndex();
}

@Override
public void pageIndexChanged(int oldPageNumber, int newPageNumber, PageableController controller) {
    currentPageIndexField.setText("" + (controller.getCurrentPage() + 1));
    refreshEnabled(controller);
}

@Override
public void totalElementsChanged(long oldTotalElements, long newTotalElements, PageableController controller) {
    totalPagesLabel.setText("" + controller.getTotalPages());
    upatePageSize();
    refreshEnabled(controller);
}

@Override
public void pageSizeChanged(int oldPageSize, int newPageSize, PageableController controller) {
    pageSizeField.setText("" + controller.getPageSize());
    totalPagesLabel.setText("" + controller.getTotalPages());
    refreshEnabled(controller);
}

@Override
public void sortChanged(
        String oldPopertyName,
        String propertyName,
        int oldSortDirection,
        int sortDirection,
        PageableController paginationController) {
    // Do nothing
}

private int getValidPageIndex() {
    PageableController controller = getController();
    int currentPageIndex = controller.getCurrentPage() + 1;
    int pageIndex = currentPageIndex;
    try {
        pageIndex = Integer.parseInt(currentPageIndexField.getText());
    } catch (NumberFormatException exception) {}

    if (pageIndex < 1) {
        return currentPageIndex;
    }

    int totalPages = controller.getTotalPages();
    if (pageIndex > totalPages) {
        return totalPages;
    }

    return pageIndex;
}

private int getValidPageSize() {

    PageableController controller = getController();
    int currentPageSize = controller.getPageSize();
    int pageSize = currentPageSize;
    try {
        pageSize = Integer.parseInt(pageSizeField.getText());
    } catch (NumberFormatException exception) {}

    if (pageSize < 1) {
        return currentPageSize;
    }

    if (pageSize > maxPageSize) {
        return currentPageSize;
    }

    return pageSize;
}

private void refreshEnabled(PageableController controller) {
    resultLabel.setText(getResultsText(controller));

    boolean hasPrevious = controller.hasPreviousPage();
    first.setEnabled(hasPrevious);
    previous.setEnabled(hasPrevious);

    boolean hasNext = controller.hasNextPage();
    next.setEnabled(hasNext);
    last.setEnabled(hasNext);
}

private static String getResultsText(PageableController controller) {
    int start = controller.getPageOffset() + 1;
    int end = start + controller.getPageSize() - 1;
    long total = controller.getTotalElements();
    if (end > total) {
        end = (int) total;
    }

    return "Rows  " + start + "..." + end + " of " + total;

}

//#end region

}