Java 如何允许用户拖放vaadin表中的行？

我有一个包含多行自定义组件的表。我想允许用户拖放行

我尝试了以下代码，但无法拖动任何行：

tblStructure = new Table();
tblStructure.setSizeFull();
tblStructure.setSelectable(false);
tblStructure.setSortEnabled(false);
tblStructure.setDragMode(Table.TableDragMode.ROW);
tblStructure.setNullSelectionAllowed(true);
tblStructure.setDropHandler(new DropHandler() {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        @Override
        public AcceptCriterion getAcceptCriterion() {
            return AcceptAll.get();
        }

        @Override
        public void drop(DragAndDropEvent event) {
        }
    });

---

您需要在

drop（DragAndDropEvent事件）

方法中编写逻辑。这里有两个链接提供更多信息：

---

将包含逻辑的代码添加到drop（..）方法中。 下面是拖放示例中的代码：

table.setDragMode(TableDragMode.ROW);
    table.setDropHandler(new DropHandler() {
        @Override
        public void drop(final DragAndDropEvent dropEvent) {
            // criteria verify that this is safe
            final DataBoundTransferable t = (DataBoundTransferable) dropEvent
                    .getTransferable();
            if (!(t.getSourceContainer() instanceof Container.Hierarchical)) {
                return;
            }
            final Container.Hierarchical source = (Container.Hierarchical) t
                    .getSourceContainer();

            final Object sourceItemId = t.getItemId();

            // find and convert the item(s) to move

            final Object parentItemId = source.getParent(sourceItemId);
            // map from moved source item Id to the corresponding Hardware
            final LinkedHashMap<Object, Hardware> hardwareMap = new LinkedHashMap<Object, Hardware>();
            if (parentItemId == null) {
                // move the whole subtree
                final String category = getTreeNodeName(source,
                        sourceItemId);
                final Collection<?> children = source
                        .getChildren(sourceItemId);
                if (children != null) {
                    for (final Object childId : children) {
                        final String name = getTreeNodeName(source, childId);
                        hardwareMap.put(childId, new Hardware(name,
                                category));
                    }
                }
            } else {
                // move a single hardware item
                final String category = getTreeNodeName(source,
                        parentItemId);
                final String name = getTreeNodeName(source, sourceItemId);
                hardwareMap.put(sourceItemId, new Hardware(name, category));
            }

            // move item(s) to the correct location in the table

            final AbstractSelectTargetDetails dropData = ((AbstractSelectTargetDetails) dropEvent
                    .getTargetDetails());
            final Object targetItemId = dropData.getItemIdOver();

            for (final Object sourceId : hardwareMap.keySet()) {
                final Hardware hardware = hardwareMap.get(sourceId);
                if (targetItemId != null) {
                    switch (dropData.getDropLocation()) {
                    case BOTTOM:
                        tableContainer.addItemAfter(targetItemId, hardware);
                        break;
                    case MIDDLE:
                    case TOP:
                        final Object prevItemId = tableContainer
                                .prevItemId(targetItemId);
                        tableContainer.addItemAfter(prevItemId, hardware);
                        break;
                    }
                } else {
                    tableContainer.addItem(hardware);
                }
                source.removeItem(sourceId);
            }
        }

        @Override
        public AcceptCriterion getAcceptCriterion() {
            return new And(acceptCriterion, AcceptItem.ALL);
        }
    });

table.setDragMode（TableDragMode.ROW）；
table.setDropHandler（新的DropHandler（）{
@凌驾
公共作废放弃（最终DragAndDropEvent放弃事件）{
//标准验证这是安全的
最终DataBoundTransferable t=（DataBoundTransferable）dropEvent
.getTransferable（）；
if（！（t.getSourceContainer（）instanceof Container.hierarchy））{
返回；
}
final Container.hierarchy source=（Container.hierarchy）t
.getSourceContainer（）；
最终对象sourceItemId=t.getItemId（）；
//查找并转换要移动的项目
最终对象parentItemId=source.getParent（sourceItemId）；
//从移动的源项Id映射到相应的硬件
最终LinkedHashMap硬件映射=新LinkedHashMap（）；
if（parentItemId==null）{
//移动整个子树
最终字符串类别=GetTreneodeName（源，
sourceItemId）；
最终集合子项=源
.getChildren（sourceItemId）；
如果（子项！=null）{
for（最终对象childId:children）{
最后一个字符串名=GetTreneNodeName（源，childId）；
hardwareMap.put（儿童ID，新硬件（名称，
类别),；
}
}
}否则{
//移动单个硬件项
最终字符串类别=GetTreneodeName（源，
parentItemId）；
最终字符串名称=GetTreneodeName（源，sourceItemId）；
hardwareMap.put（sourceItemId，新硬件（名称、类别））；
}
//将项目移动到表中的正确位置
最终AbstractSelectTargetDetails dropData=（（AbstractSelectTargetDetails）dropEvent
.getTargetDetails（））；
最终对象targetItemId=dropData.getItemIdOver（）；
for（最终对象源ID:hardwareMap.keySet（））{
最终硬件=hardwareMap.get（sourceId）；
if（targetItemId！=null）{
开关（dropData.getDropLocation（））{
箱底：
tableContainer.addItemAfter（targetItemId，硬件）；
打破
案例中：
案例顶部：
最终对象PreviItemId=tableContainer
.PreviItemId（targetItemId）；
tableContainer.addItemAfter（PreviItemId，硬件）；
打破
}
}否则{
tableContainer.addItem（硬件）；
}
source.removietem（sourceId）；
}
}
@凌驾
公共AcceptCriteria GetAcceptCriteria（）{
返回新的和（AcceptCriteria、AcceptItem.ALL）；
}
});

我知道我正在响应一个旧线程。我发现在瓦丁会很麻烦。我拒绝使用TreeTable或其他组件来实现此结果。我想和任何搜索这个的人分享我的解决方案，因为我自己找不到一个简单明了的答案。我也想为社区做点什么作为回报，因为我们使用了很多开源软件

创建一个类，例如SortableTable，它扩展了常规的Vaadin表

public class SortableTable extends Table {
    private static final long serialVersionUID = 1L;

    public SortableTable() {
        setDragMode(TableDragMode.ROW);
        setSelectable(true);
        setDropHandler(new DropHandler() {
            private static final long serialVersionUID = 1L;

            @Override
            public AcceptCriterion getAcceptCriterion() {
                return AcceptAll.get();
            }

            @Override
            public void drop(DragAndDropEvent event) {
                Transferable t = event.getTransferable();
                Object sourceItemId = t.getData("itemId");

                AbstractSelectTargetDetails dropData = (AbstractSelectTargetDetails)event.getTargetDetails();
                Object targetItemId = dropData.getItemIdOver();

                switch(dropData.getDropLocation()) {
                case BOTTOM:
                    moveAfter(targetItemId, sourceItemId);
                    break;
                case MIDDLE:
                case TOP:
                    final Object prevItemId = prevItemId(targetItemId);
                    moveAfter(prevItemId, sourceItemId);
                    break;
                }
            }
        });
    }
...

接下来，创建此自定义函数以移动表项

    @SuppressWarnings("unchecked")
    /**
     * 
     * @param targetItemId
     * @param sourceItemId
     * @return ItemId of the object the item moved to
     */
    public Object moveAfter(Object targetItemId, Object sourceItemId) {
        if(sourceItemId == null)
            return null;
        Item sourceItem = getItem(sourceItemId);

        Object[] propertyIds = getContainerPropertyIds().toArray();
        int size = propertyIds.length;
        Object[][] properties = new Object[size][2];

        // backup source item properties and values
        for(int i = 0; i < size; i++) {
            Object propertyId = propertyIds[i];
            Object value = sourceItem.getItemProperty(propertyId).getValue();
            properties[i][0] = propertyId;
            properties[i][1] = value;
        }
        removeItem(sourceItemId);
        Item item = addItemAfter(targetItemId, sourceItemId);

        // restore source item properties and values
        for(int i = 0; i < size; i++) {
            Object propertyId = properties[i][0];
            Object value = properties[i][1];
            item.getItemProperty(propertyId).setValue(value);
        }

        return sourceItemId;
    }


}

@SuppressWarnings（“未选中”）
/**
* 
*@param targetItemId
*@param sourceItemId
*@return项目移动到的对象的ItemId
*/
公共对象moveAfter（对象targetItemId、对象sourceItemId）{
if（sourceItemId==null）
返回null；
Item sourceItem=getItem（sourceItemId）；
对象[]propertyIds=getContainerPropertyIds（）.toArray（）；
int size=propertyIds.length；
对象[][]属性=新对象[大小][2]；
//备份源项属性和值
对于（int i=0；i

让我们来解释一下。由于某些明显的原因，在调用removeItem时，表项会被完全删除。除了将同一对象的属性和值复制到新行之外，无法将其放回表中。这正是自定义moveAfter所做的。代码的另一部分受Nebras在前一篇文章中提到的Vaadin Sampler中的“树到表的拖放”示例的启发

我希望我能在这个职位上帮助别人。你好！：）

看看这些链接：和