Java SWT树节点的拖动类型可以是什么

我有一个SWT树，它有图像和其他文本以及多层次的子级。 现在，我想拖动此树节点，但无法获取此树节点的正确传输类型。 因此，一旦我拖动，我就不会得到拖动图像。 是否有任何默认传输类型可用于相同的传输

下面是我的树-

我使用了以下转移，但没有工作-

Transfer[] types = new Transfer[] {FileTransfer.getInstance(),ImageTransfer.getInstance() };

---

我仍然不能完全确定您要求的是什么，但此代码即使与

Image

s一起工作

如果您的文本不能用作标识符，您可以想出其他方法：

private static Map<String, Image>   mapping = new HashMap<String, Image>();

public static void main(String[] args)
{
    Display display = new Display();
    final Shell shell = new Shell(display);
    shell.setText("StackOverflow");
    shell.setLayout(new FillLayout());

    Tree tree = new Tree(shell, SWT.NONE);

    Image[] images = new Image[] { display.getSystemImage(SWT.ICON_WARNING),
            display.getSystemImage(SWT.ICON_ERROR), display.getSystemImage(SWT.ICON_INFORMATION),
            display.getSystemImage(SWT.ICON_QUESTION) };

    for (int i = 0; i < 10; i++)
    {
        TreeItem item = new TreeItem(tree, SWT.NONE);
        item.setText("Item " + i);
        item.setImage(images[i % images.length]);
        mapping.put("Item " + i, images[i % images.length]);
    }

    initDnD(display, tree);

    shell.pack();
    shell.open();
    while (!shell.isDisposed())
    {
        if (!display.readAndDispatch())
            display.sleep();
    }
    display.dispose();
}

private static void initDnD(final Display display, final Tree tree)
{
    Transfer[] types = new Transfer[] { TextTransfer.getInstance() };
    int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;

    final DragSource source = new DragSource(tree, operations);
    source.setTransfer(types);

    final TreeItem[] dragSourceItem = new TreeItem[1];
    source.addDragListener(new DragSourceListener()
    {
        public void dragStart(DragSourceEvent event)
        {
            TreeItem[] selection = tree.getSelection();
            if (selection.length > 0 && selection[0].getItemCount() == 0)
            {
                event.doit = true;
                dragSourceItem[0] = selection[0];
            }
            else
            {
                event.doit = false;
            }
        };

        public void dragSetData(DragSourceEvent event)
        {
            event.data = dragSourceItem[0].getText();
        }

        public void dragFinished(DragSourceEvent event)
        {
            if (event.detail == DND.DROP_MOVE)
                dragSourceItem[0].dispose();
            dragSourceItem[0] = null;
        }
    });

    DropTarget target = new DropTarget(tree, operations);
    target.setTransfer(types);
    target.addDropListener(new DropTargetAdapter()
    {
        public void dragOver(DropTargetEvent event)
        {
            event.feedback = DND.FEEDBACK_SCROLL;
            if (event.item != null)
            {
                TreeItem item = (TreeItem) event.item;
                Point pt = display.map(null, tree, event.x, event.y);
                Rectangle bounds = item.getBounds();
                if (pt.y < bounds.y + bounds.height / 3)
                {
                    event.feedback |= DND.FEEDBACK_INSERT_BEFORE;
                }
                else if (pt.y > bounds.y + 2 * bounds.height / 3)
                {
                    event.feedback |= DND.FEEDBACK_INSERT_AFTER;
                }
            }
        }

        public void drop(DropTargetEvent event)
        {
            if (event.data == null)
            {
                event.detail = DND.DROP_NONE;
                return;
            }
            String text = (String) event.data;
            if (event.item != null)
            {
                TreeItem item = (TreeItem) event.item;
                Point pt = display.map(null, tree, event.x, event.y);
                Rectangle bounds = item.getBounds();

                TreeItem[] items = tree.getItems();
                int index = 0;
                for (int i = 0; i < items.length; i++)
                {
                    if (items[i] == item)
                    {
                        index = i;
                        break;
                    }
                }

                if (pt.y < bounds.y + bounds.height / 3)
                {
                    TreeItem newItem = new TreeItem(tree, SWT.NONE, index);
                    newItem.setText(text);
                    newItem.setImage(mapping.get(text));
                }
                else if (pt.y > bounds.y + 2 * bounds.height / 3)
                {
                    TreeItem newItem = new TreeItem(tree, SWT.NONE, index + 1);
                    newItem.setText(text);
                    newItem.setImage(mapping.get(text));
                }
                else
                {
                    TreeItem newItem = new TreeItem(item, SWT.NONE);
                    newItem.setText(text);
                    newItem.setImage(mapping.get(text));
                }
            }
        }
    });
}

private静态映射=newhashmap（）；
公共静态void main（字符串[]args）
{
显示=新显示（）；
最终外壳=新外壳（显示）；
shell.setText（“StackOverflow”）；
setLayout（新的FillLayout（））；
Tree Tree=新树（shell，SWT.NONE）；
Image[]images=新图像[]{display.getSystemImage（SWT.ICON_警告），
display.getSystemImage（SWT.ICON\u错误），display.getSystemImage（SWT.ICON\u信息），
display.getSystemImage（SWT.ICON\u QUESTION）}；
对于（int i=0；i<10；i++）
{
TreeItem=新的TreeItem（树，SWT.NONE）；
项目.setText（“项目”+i）；
item.setImage（图像[i%images.length]）；
mapping.put（“项”+i，图像[i%images.length]）；
}
initDnD（显示，树）；
shell.pack（）；
shell.open（）；
而（！shell.isDisposed（））
{
如果（！display.readAndDispatch（））
display.sleep（）；
}
display.dispose（）；
}
私有静态void initDnD（最终显示，最终树）
{
传输[]类型=新传输[]{TextTransfer.getInstance（）}；
int operations=DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK；
最终DragSource源=新的DragSource（树，操作）；
source.setTransfer（类型）；
最终树项[]dragSourceItem=新树项[1]；
source.addDragListener（新的DragSourceListener（）
{
公共作废dragStart（DragSourceEvent事件）
{
TreeItem[]selection=tree.getSelection（）；
如果（selection.length>0&&selection[0].getItemCount（）==0）
{
event.doit=true；
dragSourceItem[0]=选择[0]；
}
其他的
{
event.doit=false；
}
};
公共作废dragSetData（DragSourceEvent事件）
{
event.data=dragSourceItem[0].getText（）；
}
公共无效dragFinished（DragSourceEvent事件）
{
如果（event.detail==DND.DROP\u MOVE）
dragSourceItem[0]。dispose（）；
dragSourceItem[0]=null；
}
});
DropTarget目标=新的DropTarget（树，操作）；
target.setTransfer（类型）；
addDropListener（新的DropTargetAdapter（）
{
公共无效dragOver（DropTargetEvent事件）
{
event.feedback=DND.feedback\u滚动；
如果（event.item！=null）
{
TreeItem item=（TreeItem）event.item；
点pt=display.map（null，tree，event.x，event.y）；
矩形边界=item.getBounds（）；
if（pt.ybounds.y+2*bounds.height/3）
{
event.feedback |=DND.feedback _插入_之后；
}
}
}
公共作废删除（DropTargetEvent事件）
{
如果（event.data==null）
{
event.detail=DND.DROP\u无；
返回；
}
字符串文本=（字符串）event.data；
如果（event.item！=null）
{
TreeItem item=（TreeItem）event.item；
点pt=display.map（null，tree，event.x，event.y）；
矩形边界=item.getBounds（）；
TreeItem[]items=tree.getItems（）；
int指数=0；
对于（int i=0；ibounds.y+2*bounds.height/3）
{
TreeItem newItem=新的TreeItem（树，SWT.NONE，索引+1）；
newItem.setText（文本）；
setImage（mapping.get（text））；
}
其他的
{
TreeItem newItem=新的TreeItem（项目，SWT.NONE）；
newItem.setText（文本）；
setImage（mapping.get（text））；
}
}
}
});
}

你看了吗？是的，它使用textTransfer，但对我来说，它不仅仅是文本，所以我想要一个能接受任何东西的东西来起草。这是我关心的问题。实际上，我想接受任何要拖动的内容，而不考虑文本或任何类型的对象在我的RCP应用程序上的可用性。因此，如何做到这一点……理想情况下，我相信继承、转让和做一些事情可能会奏效，而这正是我正在努力的方向。