DataGrid中的GWT CellTree不会对鼠标点击做出反应

Question

我已将GWT-CellTree放入DataGrid中。它的工作原理除外：当点击tree-expand-icon时，没有任何反应。我试图尽量减少 重现问题所需的代码...

如何解决这个问题？

最好的问候，马格努斯

package com.raybased.gwt.configtool.client.grid;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.cellview.client.DataGrid;
import com.google.gwt.user.client.ui.RootLayoutPanel;
import com.google.gwt.user.client.ui.SimpleLayoutPanel;

public class HelloWorld implements EntryPoint {
public void onModuleLoad() {
    DataGrid grid= (DataGrid) new NodesGrid().getTable();
    grid.setWidth("100%");
    SimpleLayoutPanel slp = new SimpleLayoutPanel();
    slp.add(grid);
    RootLayoutPanel.get().add(slp);
}
}


package com.raybased.gwt.configtool.client.grid;

import com.google.gwt.cell.client.ClickableTextCell;
import com.google.gwt.cell.client.FieldUpdater;
import com.google.gwt.dom.client.Style;
import com.google.gwt.safehtml.shared.SafeHtml;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.text.shared.AbstractSafeHtmlRenderer;
import com.google.gwt.text.shared.SafeHtmlRenderer;
import com.google.gwt.user.cellview.client.*;
import com.google.gwt.user.cellview.client.HasKeyboardSelectionPolicy.KeyboardSelectionPolicy;
import com.google.gwt.view.client.ListDataProvider;

import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;

public class NodesGrid {
private AbstractCellTable<Node> table = new DataGrid<>();
private Column nameColumn;
private Column<Node, String> showBlocksColumn;
private final Set<Integer> showBlocks = new HashSet<>();


public Column getNameColumn() {
    return nameColumn;
}

public AbstractCellTable<Node> getTable() {
    return table;
}

public NodesGrid() {
    table.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.ENABLED);
    table.setWidth("100%");
    CustomCellTableBuilder c = new CustomCellTableBuilder(this, table);
    table.setTableBuilder(c);
    Node nodes = new Node();
    nodes.setName("hello");
    nodes.setId(123);
    Node n2 = new Node();
    n2.setName("testing");
    nodes.getBlocks().add(n2);
    ListDataProvider<Node> dataProvider = new ListDataProvider<>();
    dataProvider.addDataDisplay(table);
    List<Node> list = dataProvider.getList();
    list.add(nodes);
    addShowBlocks();
    nameColumn = getSorter(list, "Name", Comparator.comparing(Node::getName), Node::getName);
}

private Column getSorter(List<Node> list,
             String name,
             Comparator<Node> cmp,
             Function<Node, String> supplier) {
    TextColumn<Node> column = new TextColumn<Node>() {
    @Override
    public String getValue(Node object) {
        return supplier.apply(object);
    }
    };
    table.addColumn(column, name);
    column.setSortable(true);
    ColumnSortEvent.ListHandler<Node> columnSortHandler = new ColumnSortEvent.ListHandler<>(list);
    columnSortHandler.setComparator(column, cmp);
    table.addColumnSortHandler(columnSortHandler);
    table.getColumnSortList().push(column);
    return column;
}

public Column<Node, String> getShowBlocksColumn() {
    return showBlocksColumn;
}

public Set<Integer> getShowBlocks() {
    return showBlocks;
}

void addShowBlocks() {
    SafeHtmlRenderer<String> anchorRenderer = new AbstractSafeHtmlRenderer<String>() {
    @Override
    public SafeHtml render(String object) {
        SafeHtmlBuilder sb = new SafeHtmlBuilder();
        sb.appendHtmlConstant("(<a href=\"javascript:;\">").appendEscaped(object)
            .appendHtmlConstant("</a>)");
        return sb.toSafeHtml();
    }
    };
    showBlocksColumn = new Column<Node, String>(new ClickableTextCell(anchorRenderer)) {
    @Override
    public String getValue(Node node) {
        if (showBlocks.contains(node.getId())) {
        return "hide blocks";
        } else {
        return "show blocks";
        }
    }
    };
    showBlocksColumn.setFieldUpdater(new FieldUpdater<Node, String>() {
    @Override
    public void update(int index, Node node, String value) {
        if (showBlocks.contains(node.getId())) {
        showBlocks.remove(node.getId());
        } else {
        showBlocks.add(node.getId());
        }
        table.redrawRow(index);
    }
    });
    table.addColumn(showBlocksColumn);
    table.setColumnWidth(0, 10, Style.Unit.EM);
}
}


package com.raybased.gwt.configtool.client.grid;

import com.google.gwt.cell.client.AbstractCell;
import com.google.gwt.cell.client.Cell;
import com.google.gwt.cell.client.TextCell;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.user.cellview.client.CellTree;
import com.google.gwt.user.cellview.client.HasKeyboardSelectionPolicy.KeyboardSelectionPolicy;
import com.google.gwt.user.cellview.client.TreeNode;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.view.client.ListDataProvider;
import com.google.gwt.view.client.SingleSelectionModel;
import com.google.gwt.view.client.TreeViewModel;

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

public class NodesTree {
private CellTree tree;

public NodesTree(Node node) {
    TreeViewModel model = new CustomTreeModel(node);
    tree = new CellTree(model, null);
    tree.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.ENABLED);
    TreeNode rootNode = tree.getRootTreeNode();
    openAll(rootNode);
}


private static class TopLevel {
    private final String name;
    private List<Node> blocks = new ArrayList<>();

    public TopLevel(String name) {
    this.name = name;
    }

    public TopLevel(String name, List<Node> blocks) {
    this.name = name;
    this.blocks = blocks;
    }

    public String getName() {
    return name;
    }

    public List<Node> getBlocks() {
    return blocks;
    }

}


private static class CustomTreeModel implements TreeViewModel {

    private final List<TopLevel> topLevels;

    private final SingleSelectionModel<String> selectionModel
        = new SingleSelectionModel<>();

    public CustomTreeModel(Node node) {
    topLevels = new ArrayList<>();
    {
        TopLevel blocksNode = new TopLevel("Blocks", new ArrayList(node.getBlocks()));
        topLevels.add(blocksNode);
    }

    {
        TopLevel outgoing = new TopLevel("Outgoing");
        topLevels.add(outgoing);
    }

    {
        TopLevel incoming = new TopLevel("Incoming");
        topLevels.add(incoming);
    }
    }

    public <T> NodeInfo<?> getNodeInfo(T value) {
    if (value == null) {
        // LEVEL 0.
        ListDataProvider<TopLevel> dataProvider
            = new ListDataProvider<>(
            topLevels);
        Cell<TopLevel> cell = new AbstractCell<TopLevel>() {
        @Override
        public void render(Context context, TopLevel value, SafeHtmlBuilder sb) {
            sb.appendHtmlConstant("    ");
            sb.appendEscaped(value.getName());
        }
        };
        return new DefaultNodeInfo<>(dataProvider, cell);
    } else if (value instanceof TopLevel) {
        // LEVEL 1.
        ListDataProvider<Node> dataProvider = new ListDataProvider<>(((TopLevel) value).getBlocks());
        Cell<Node> cell = new AbstractCell<Node>() {
        @Override
        public void render(Context context, Node value, SafeHtmlBuilder sb) {
            if (value != null) {
            sb.appendHtmlConstant("    ");
            sb.appendEscaped("(" + value.getName() + ")");
            }
        }
        };
        return new DefaultNodeInfo<>(dataProvider, cell);
    } else if (value instanceof Node) {
        // LEVEL 2 - LEAF.
        String params = "test";
        ArrayList<String> str = new ArrayList<>();
        str.add(params);
        ListDataProvider<String> dataProvider = new ListDataProvider<>(str);
        return new DefaultNodeInfo<>(dataProvider, new TextCell(), selectionModel, null);
    }
    return null;
    }

    public boolean isLeaf(Object value) {
    if (value instanceof String) {
        return true;
    }
    return false;
    }
}

private void openAll(TreeNode rootNode) {
    if (rootNode == null) return;
    for (int i = 0; i < rootNode.getChildCount(); i++) {
    TreeNode node = rootNode.setChildOpen(i, true);
    openAll(node);
    }
}

public Widget getWidget() {
    return tree;
}
}


package com.raybased.gwt.configtool.client.grid;

import com.google.gwt.dom.builder.shared.DivBuilder;
import com.google.gwt.dom.builder.shared.TableCellBuilder;
import com.google.gwt.dom.builder.shared.TableRowBuilder;
import com.google.gwt.dom.client.Style;
import com.google.gwt.safehtml.shared.SafeHtmlUtils;
import com.google.gwt.user.cellview.client.AbstractCellTable;
import com.google.gwt.user.cellview.client.AbstractCellTableBuilder;
import com.google.gwt.user.cellview.client.Column;
import com.google.gwt.view.client.SelectionModel;

public class CustomCellTableBuilder extends AbstractCellTableBuilder<Node> {
NodesGrid nodesGrid;

private final String rowStyle;
private final String selectedRowStyle;
private final String cellStyle;
private final String selectedCellStyle;

/**
 * Construct a new table builder.
 *
 * @param cellTable the table this builder will build rows for
 */
public CustomCellTableBuilder(NodesGrid nodesGrid, AbstractCellTable<Node> cellTable) {
    super(cellTable);
    this.nodesGrid = nodesGrid;
    AbstractCellTable.Style style = cellTable.getResources().style();
    rowStyle = style.evenRow();
    selectedRowStyle = " " + style.selectedRow();
    cellStyle = style.cell() + " " + style.evenRowCell();
    selectedCellStyle = " " + style.selectedRowCell();
}

@Override
protected void buildRowImpl(Node rowValue, int absRowIndex) {
    // Calculate the row styles.
    SelectionModel<? super Node> selectionModel = cellTable.getSelectionModel();
    boolean isSelected =
        (selectionModel == null || rowValue == null) ? false : selectionModel
            .isSelected(rowValue);
    StringBuilder trClasses = new StringBuilder(rowStyle);
    if (isSelected) {
    trClasses.append(selectedRowStyle);
    }

    String cellStyles = cellStyle;
    if (isSelected) {
    cellStyles += selectedCellStyle;
    }
    TableRowBuilder row = startRow();
    row.className(trClasses.toString());

    buildRow(row, rowValue, cellStyles, nodesGrid.getShowBlocksColumn());
    buildRow(row, rowValue, cellStyles, nodesGrid.getNameColumn());

    row.endTR();
    if (nodesGrid.getShowBlocks().contains(rowValue.getId())) {
        buildBlockRow(rowValue, cellStyles);
    }
}

void buildRow(TableRowBuilder row, Node rowValue, String cellStyles, Column column) {
    TableCellBuilder td = row.startTD();
    td.className(cellStyles);
    td.style().outlineStyle(Style.OutlineStyle.NONE).endStyle();
    renderCell(td, createContext(0), column, rowValue);
    td.endTD();
}

private void buildBlockRow(Node rowValue, String cellStyles) {
    TableRowBuilder row = startRow();
    buildCell(rowValue, cellStyles, row);
    row.endTR();
}

private void buildCell(Node rowValue, String cellStyles, TableRowBuilder row) {
    NodesTree hw = new NodesTree(rowValue);
    TableCellBuilder td = row.startTD().colSpan(5);
    td.className(cellStyles);
    DivBuilder div = td.startDiv();
    String t = hw.getWidget().getElement().getInnerHTML();
    div.html(SafeHtmlUtils.fromTrustedString(t));
    div.end();
    td.endTD();
}
}


package com.raybased.gwt.configtool.client.grid;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class Node implements Serializable {
String name;
List<Node> blocks = new ArrayList<>();
String params;
int id;

public Node() {
}

public String getParams() {
    return params;
}

public void setParams(String params) {
    this.params = params;
}

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public List<Node> getBlocks() {
    return blocks;
}
}