SWT 中的拖放功能

 最近在项目开发中需要对树（Tree）的层次结构进行调整，由于SWT是基于操作系统的事件模型的一种开发控件，所以想到利用鼠标的拖放功能对树的节点进行移动，即直观也提高了客户体验。

SWT的拖放功能的实现主要使用了DragSource、DropTarget这两个类，开发人员只需要实现其事件的接口，既可以对控件上的文本、HTML、RTF及附件进行拖放操作，即把一个控件上的文本、HTML、RTF及附件拖放到另一个控件。

Tree是由TreeItem控件组成，所以移动树节点就相当于移动TreeItem，这里并非真的移动控件，而是把源控件的信息（文本、HTML、RTF及附件）通过事件传递到目标控件，目标控件也是新创建的，如果不是复制而只是移动，则要把源控件销毁掉。

例子实现思路及源代码：本例子为左边是目标树，右边是用TabFolder实现了几棵源树，同时目标树本身也是源树，即实现多个源对单个目标进行操作。实现过程把几个源树放到了一个Tree[ ]集合里，用于分清源树到底是哪一棵，才能得到在源树上的选择的节点。本例的主要功能是：实现把其他源树的节点移动到某一个目标树上，同时实现目标树上的节点自由替换位置。

代码：

public class SetSubSWT extends Dialog ...{

    protected Tree subtree;

    protected Tree preTree;// 单位

    protected Tree roomTree;// 科室

    protected Table unitTable;// 科室

    protected Display display;

    protected Shell shell;

    protected Tree tree;

    protected List newList = new ArrayList();

    protected List modifyList = new ArrayList();

    protected List deleteList = new ArrayList();

    protected Map map = new HashMap();

    protected Map mapSave = new HashMap();

    protected Object result;

    protected SashForm mainSashForm;

    protected TextTransfer textTransfer;

    protected FileTransfer fileTransfer;

    protected Tree[] eachTrees;

    // protected TreeItem[] dragSourceItem;

    protected int index;

    protected Map dataMap;// 缓存

    protected List typeList;// 缓存

    protected Map relMap;// 缓存

    /** *//**
     * Create the dialog
     * 
     * @param parent
     * @param style
     */
    public SetSubSWT(Shell parent, Tree subtree, Map dataMap, List typeList,
            Map relMap, int style) ...{
        super(parent, style);
        this.subtree = subtree;
        this.dataMap = dataMap;
        this.typeList = typeList;
        this.relMap = relMap;
    }

    // /**
    // * Create the dialog
    // * @param parent
    // */
    // public SetSubSWT(Shell parent) {
    // this(parent, SWT.NONE);
    // }

    // /**
    // * Launch the application
    // *
    // * @param args
    // */
    // public static void main(String[] args) {
    // try {
    // System.out.println("args[0]==" + args[0]);
    // SWTDataViewUtil.httpUrl = args[0] + "/subactionswt.do?action=";
    // SetSubSWT window = new SetSubSWT();
    // window.open();
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    // }

    /** *//**
     * Open the window
     */
    public Object open() ...{
        display = getParent().getDisplay();

        createContents();
        shell.open();
        shell.layout();
        while (!shell.isDisposed()) ...{
            if (!display.readAndDispatch())
                display.sleep();
        }
        return result;
    }

    /** *//**
     * Create contents of the window
     */
    protected void createContents() ...{
        shell = new Shell();
        shell.setLayout(new FillLayout());
        shell.setText("会计科目设置");

        /**//*
         * Transfer是一个可以提供数据在Java representation与platform specific
         * representation 之间交互的抽象类.下面是几个format： TextTransfer String "hello
         * world" RTFTransfer String "{/rtf1/b/i hello world}" FileTransfer
         * String[] new String[] {file1.getAbsolutePath(),
         * file2.getAbsolutePath()}
         * 
         * TransferData包含了很多特定于平台的公用的属性，应用不应该直接去访问这些属性。
         * 如果真的有必要去访问这些属性，那么我们可以通过扩展Transfer类来完成对特定平台的额外操作。
         */
        textTransfer = TextTransfer.getInstance();
        fileTransfer = FileTransfer.getInstance();

        // final Color red = display.getSystemColor(SWT.COLOR_GREEN);
        // final Color yellow = display.getSystemColor(SWT.COLOR_GRAY);
        // tree.addListener(SWT.EraseItem, new Listener() {
        // public void handleEvent(Event event) {
        // if ((event.detail & SWT.SELECTED) == 0)
        // return; /* item not selected */
        // int clientWidth = tree.getClientArea().width;
        // GC gc = event.gc;
        // Color oldForeground = gc.getForeground();
        // Color oldBackground = gc.getBackground();
        // gc.setForeground(red);
        // gc.setBackground(yellow);
        // gc.fillGradientRectangle(0, event.y, clientWidth, event.height,
        // false);
        // gc.setForeground(oldForeground);
        // gc.setBackground(oldBackground);
        // event.detail &= ~SWT.SELECTED;
        // }
        // });

        shell.setMaximized(true);
        // Canvas canvas = new Canvas(shell, SWT.BORDER);
        // canvas.setLayout(new FillLayout());

        mainSashForm = new SashForm(shell, SWT.HORIZONTAL);
        mainSashForm.setBackground(shell.getDisplay().getSystemColor(
                SWT.COLOR_TITLE_BACKGROUND));
        final Group leftGroup = new Group(mainSashForm, SWT.NONE | SWT.CENTER);
        leftGroup.setText("会计科目");
        leftGroup.setLayout(new FillLayout());
        final TabFolder subtabFolder = new TabFolder(leftGroup, SWT.NONE);

        final TabItem subtabItem = new TabItem(subtabFolder, SWT.NONE);
        subtabItem.setText("会计科目");
        tree = new Tree(subtabFolder, SWT.FULL_SELECTION);
        tree.setLinesVisible(true);
        addExistItems();
        tree.addListener(SWT.Selection, new Listener() ...{

            public void handleEvent(Event event) ...{
                System.out
                        .println(tree.getSelection()[0].getData("SetSubData"));
            }

        });
        subtabItem.setControl(tree);

        Transfer[] types = new Transfer[] ...{ TextTransfer.getInstance() };
        int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;

        final DragSource treeSource = new DragSource(tree, operations);
        treeSource.setTransfer(types);
        treeSource.addDragListener(new DragSourceListener() ...{
            public void dragStart(DragSourceEvent event) ...{
                TreeItem[] selection = ((Tree) ((DragSource) event.widget)
                        .getControl()).getSelection();
                // 只能移动选中并且为最子结点。
                // if (selection.length > 0
                // && selection[0].getItemCount() == 0) {// 选中并且为最子结点。
                if (selection.length > 0) ...{
                    event.doit = true;
                    // int selectedCount = ((Tree) ((DragSource)
                    // event.widget)
                    // .getControl()).getSelection().length;
                    // dragSourceItem = new TreeItem[selectedCount];
                    // for (int i = 0; i < selectedCount; i++) {
                    // dragSourceItem[i] = selection[i];
                    // }
                } else ...{
                    event.doit = false;
                }
            };

            public void dragSetData(DragSourceEvent event) ...{
                event.data = String.valueOf(typeList.size()); // 最后一个是保存左边树，用于移动节点位置用。;//
                // *********
            }

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

        DropTarget leftTarget = new DropTarget(tree, operations);
        leftTarget.setTransfer(types);
        leftTarget.addDropListener(new DropTargetAdapter() ...{
            public void dragOver(DropTargetEvent event) ...{
                event.feedback = DND.FEEDBACK_EXPAND | 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;
                    } else ...{
                        event.feedback |= DND.FEEDBACK_SELECT;
                    }
                }
            }

            public void drop(DropTargetEvent event) ...{
                if (event.data == null) ...{
                    event.detail = DND.DROP_NONE;
                    return;
                }
                String treeIndex = (String) event.data;
                TreeItem[] drogItems = eachTrees[Integer.parseInt(treeIndex)]
                        .getSelection();
                System.out.println(drogItems.length);
                // if (event.item == null) {
                // TreeItem item = new TreeItem(tree, SWT.NONE);
                // item.setText(text);
                // } else
                if (event.item != null) ...{// 把鼠标移到目标节点才能进行挂节点操作。
                    if (Integer.parseInt(treeIndex) != typeList.size()) ...{// 如果不是最后一颗树。
                        TreeItem item = (TreeItem) event.item;
                        Point pt = display.map(null, tree, event.x, event.y);
                        Rectangle bounds = item.getBounds();
                        TreeItem parent = item.getParentItem();
                        if (parent != null) ...{// 目标Tree有父结点时。
                            TreeItem[] items = parent.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) ...{
                                for (int i = 0; i < drogItems.length; i++) ...{
                                    TreeItem newItem = new TreeItem(parent,
                                            SWT.NONE, index);
                                    newItem.setText(drogItems[i].getText());
                                    newItem.setData("SetSubData", convertData(
                                            item, (BaseDataVO) (drogItems[i]
                                                    .getData("baseData"))));
                                }
                            } else if (pt.y > bounds.y + 2 * bounds.height / 3) ...{
                                for (int i = 0; i < drogItems.length; i++) ...{
                                    TreeItem newItem = new TreeItem(parent,
                                            SWT.NONE, index + 1);
                                    newItem.setText(drogItems[i].getText());
                                    newItem.setData("SetSubData", convertData(
                                            item, (BaseDataVO) (drogItems[i]
                                                    .getData("baseData"))));
                                }
                            } else ...{
                                for (int i = 0; i < drogItems.length; i++) ...{
                                    TreeItem newItem = new TreeItem(item,
                                            SWT.NONE);
                                    newItem.setText(drogItems[i].getText());
                                    newItem.setData("SetSubData", convertData(
                                            item, (BaseDataVO) (drogItems[i]
                                                    .getData("baseData"))));
                                }
                            }

                        } else ...{// 目标Tree没有父结点时。
                            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) ...{
                                for (int i = 0; i < drogItems.length; i++) ...{
                                    TreeItem newItem = new TreeItem(tree,
                                            SWT.NONE, index);
                                    newItem.setText(drogItems[i].getText());
                                    newItem.setData("SetSubData", convertData(
                                            item, (BaseDataVO) (drogItems[i]
                                                    .getData("baseData"))));
                                }
                            } else if (pt.y > bounds.y + 2 * bounds.height / 3) ...{
                                for (int i = 0; i < drogItems.length; i++) ...{
                                    TreeItem newItem = new TreeItem(tree,
                                            SWT.NONE, index + 1);
                                    newItem.setText(drogItems[i].getText());
                                    newItem.setData("SetSubData", convertData(
                                            item, (BaseDataVO) (drogItems[i]
                                                    .getData("baseData"))));
                                }
                            } else ...{
                                for (int i = 0; i < drogItems.length; i++) ...{
                                    TreeItem newItem = new TreeItem(item,
                                            SWT.NONE);
                                    newItem.setText(drogItems[i].getText());
                                    newItem.setData("SetSubData", convertData(
                                            item, (BaseDataVO) (drogItems[i]
                                                    .getData("baseData"))));
                                }
                            }
                        }
                    } else ...{// 如果是最后一颗树。
                        TreeItem drogItem = eachTrees[Integer
                                .parseInt(treeIndex)].getSelection()[0];
                        String text = drogItem.getText();
                        TreeItem item = (TreeItem) event.item;
                        Point pt = display.map(null, tree, event.x, event.y);
                        Rectangle bounds = item.getBounds();
                        TreeItem parent = item.getParentItem();
                        if (parent != null) ...{
                            TreeItem[] items = parent.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(parent,
                                        SWT.NONE, index);
                                newItem.setText(text);
                            } else if (pt.y > bounds.y + 2 * bounds.height / 3) ...{
                                TreeItem newItem = new TreeItem(parent,
                                        SWT.NONE, index + 1);
                                newItem.setText(text);
                            } else ...{
                                TreeItem newItem = new TreeItem(item, SWT.NONE);
                                newItem.setText(text);
                            }

                        } else ...{
                            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);
                            } else if (pt.y > bounds.y + 2 * bounds.height / 3) ...{
                                TreeItem newItem = new TreeItem(tree, SWT.NONE,
                                        index + 1);
                                newItem.setText(text);
                            } else ...{
                                TreeItem newItem = new TreeItem(item, SWT.NONE);
                                newItem.setText(text);
                            }
                        }

                    }
                }
            }

            private RelSubVO convertData(TreeItem drogItem, BaseDataVO baseVo) ...{
                RelSubVO relVo = new RelSubVO();
                String id = KeyGenerator.generateStringID();
                relVo.setId(id);
                relVo.setName(baseVo.getTitle());
                relVo.setRelid(baseVo.getId());
                relVo.setRelType(baseVo.getType());
                RelSubVO data = (RelSubVO) drogItem.getData("SetSubData");
                SubVO subVo = (SubVO) subtree.getSelection()[0].getData();
                if (data == null) ...{
                    relVo.setPath("0,1");
                    relVo.setPid("1");
                    relVo.setType("0");
                    relVo.setSubid(subVo.getId());
                    relVo.setAsid("1001");
                } else ...{
                    relVo.setAsid("1001");
                    relVo.setPath(data.getPath() + "," + data.getId());
                    relVo.setPid(data.getId());
                    data.setType("1");// 父的目录类型设为1，表示目录
                    // 如果是在newList 里面，而没有保存到数据库的，则仍在newList里。
                    if (!newList.contains(data)) ...{
                        if (modifyList.contains(data)) ...{
                            modifyList.remove(data);
                        }
                        modifyList.add(data);
                    }
                    relVo.setType("0");// 子的目录类型设为0，表示最子节点
                    relVo.setSubid(subVo.getId());
                }
                newList.add(relVo);// 每挂一次就在newList添加
                return relVo;

            }
        });

        final Group rightGroup = new Group(mainSashForm, SWT.NONE | SWT.CENTER);
        rightGroup.setText("基础数据");
        rightGroup.setLayout(new FillLayout());
        final TabFolder tabFolder = new TabFolder(rightGroup, SWT.NONE);

        addTabItems(tabFolder);

        eachTrees[typeList.size()] = tree; // 最后一个是保存左边树，用于移动节点位置用。

        tree.addTreeListener(new TreeListener() ...{
            public void treeCollapsed(TreeEvent e) ...{
                TreeItem item = (TreeItem) e.item;
                // item.setImage(closeImg);
            }

            public void treeExpanded(TreeEvent e) ...{
                TreeItem item = (TreeItem) e.item;
                // item.setImage(openImg);
            }

        });
        // tree.addListener(SWT.MeasureItem, new Listener() {
        // public void handleEvent(Event event) {
        // int clientWidth = tree.getClientArea().width;
        // event.height = event.gc.getFontMetrics().getHeight() + 5;
        // event.width = clientWidth;
        // }
        // });
        //        

        Menu menu = new Menu(shell, SWT.POP_UP);
        initMenuItems(menu);
        tree.setMenu(menu);

        // 将dropTable指定为Drop Target,
        // DropTarget target=new
        // DropTarget(tree,DND.DROP_MOVE|DND.DROP_COPY|DND.DROP_DEFAULT);
        // target.setTransfer(new Transfer[] {textTransfer });
        // target.addDropListener(new MyDropTargetListener());

        final Menu toolBarMenu = new Menu(shell, SWT.BAR);
        initMenuItems(toolBarMenu);
        shell.setMenuBar(toolBarMenu);

        mainSashForm.setWeights(new int[] ...{ 5, 5 });
    }

    private void addExistItems() ...{

        TreeItem ti0 = new TreeItem(tree, SWT.NONE);
        ti0.setText(subtree.getSelection()[0].getText());
        SubVO pvo = (SubVO) subtree.getSelection()[0].getData();

        pvo.setSublevel("0");
        pvo.setSubpath("0");
        pvo.setSubtype("1");// 默认是叶子，如果有子节点则变为1，1表示目录
        ti0.setData(pvo);

        map.put("1", ti0);

        if (relMap == null) ...{
            relMap = (Map) SWTDataViewUtil.parseObject(null, "loadRelSub");
        }

        if (relMap == null) ...{
            return;
        }

        List relList = (List) relMap.get(pvo.getId());

        if (relList == null) ...{
            return;
        }

        for (int i = 0; i < relList.size(); i++) ...{
            RelSubVO vo = (RelSubVO) relList.get(i);

            TreeItem ti = new TreeItem((TreeItem) map.get(vo.getPid()),
                    SWT.NONE);
            ti.setText(vo.getName());
            ti.setData("SetSubData", vo);
            ti.setExpanded(true);

            if (vo.getType().equals("1")) ...{// 如果为目录
                map.put(vo.getId(), ti);// 只保存有目录的节点，不保存无叶子节点的节点。
            }

        }
        ti0.setExpanded(true);
    }

    private void addTabItems(TabFolder tabFolder) ...{
        if (dataMap == null || typeList == null) ...{
            dataMap = (Map) SWTDataViewUtil.parseObject(null, "getBaseDataMap");
            typeList = (List) SWTDataViewUtil.parseObject(null, "getTypeList");
        }
        if (typeList == null)
            return;
        eachTrees = new Tree[typeList.size() + 1]; // 最后一个是保存左边树，用于移动节点位置用。
        for (index = 0; index < typeList.size(); index++) ...{
            LabelValue lv = (LabelValue) typeList.get(index);
            List dataList = (List) dataMap.get(lv.getValue());

            final TabItem tabPreItem = new TabItem(tabFolder, SWT.NONE);
            tabPreItem.setText(lv.getLabel());
            eachTrees[index] = new Tree(tabFolder, SWT.FULL_SELECTION
                    | SWT.MULTI);
            eachTrees[index].setLinesVisible(true);
            tabPreItem.setControl(eachTrees[index]);

            // 将dragLabel指定为DragSource(一个widget只能帮定在一个DragSource)，
            // 并允许数据可以从DragSource被MOVE或COPY
            // DragSource source=new
            // DragSource(eachTree,DND.DROP_MOVE|DND.DROP_COPY);
            // source.setTransfer(new Transfer[] { textTransfer });// 指定允许的传输类型
            // source.addDragListener(new MyDragSourceListener());

            Transfer[] types = new Transfer[] ...{ TextTransfer.getInstance() };
            int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;
            final DragSource rightSource = new DragSource(eachTrees[index],
                    operations);
            rightSource.setTransfer(types);
            rightSource.addDragListener(new DragSourceListener() ...{
                public void dragStart(DragSourceEvent event) ...{
                    TreeItem[] selection = ((Tree) ((DragSource) event.widget)
                            .getControl()).getSelection();
                    // 只能移动选中并且为最子结点。
                    // if (selection.length > 0
                    // && selection[0].getItemCount() == 0) {// 选中并且为最子结点。
                    if (selection.length > 0) ...{
                        event.doit = true;
                        // int selectedCount = ((Tree) ((DragSource)
                        // event.widget)
                        // .getControl()).getSelection().length;
                        // dragSourceItem = new TreeItem[selectedCount];
                        // for (int i = 0; i < selectedCount; i++) {
                        // dragSourceItem[i] = selection[i];
                        // }
                    } else ...{
                        event.doit = false;
                    }
                };

                public void dragSetData(DragSourceEvent event) ...{

                    for (int i = 0; i < typeList.size(); i++) ...{// 获得哪颗树。
                        if (((Tree) ((DragSource) event.widget).getControl()) == eachTrees[i]) ...{
                            event.data = String.valueOf(i);// *********
                            return;
                        }
                    }
                }

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

            addItems(eachTrees[index], dataList);

            System.out.println(lv.getLabel() + "数据开始>>>>>>");

            eachTrees[index].addListener(SWT.Selection, new Listener() ...{

                public void handleEvent(Event event) ...{
                    if (event.detail == SWT.CHECK) ...{
                        TreeItem checkItem = (TreeItem) event.item;
                        System.out.println(checkItem.getData("baseData"));
                        if (checkItem != null) ...{
                            boolean ischeck = checkItem.getChecked();
                            if (checkItem.getItemCount() != 0) ...{
                                SWTCheckUtil.doChildCheck(checkItem, ischeck);
                            }

                        }
                    }
                }

            });

        }

    }

    private void addItems(Tree eachTree, List dataList) ...{
        Map itemMap = new HashMap();
        if (dataList == null)
            return;
        for (int i = 0; i < dataList.size(); i++) ...{
            BaseDataVO baseData = (BaseDataVO) dataList.get(i);

            TreeItem ti = null;
            if (itemMap.get(baseData.getPid()) == null) ...{
                ti = new TreeItem(eachTree, SWT.NONE);
            } else ...{

                ti = new TreeItem((TreeItem) itemMap.get(baseData.getPid()),
                        SWT.NONE);
            }
            ti.setText(baseData.getTitle());
            ti.setData("baseData", baseData);
            ti.setExpanded(true);

            if (baseData.getNodeType().equals("1")) ...{// 如果为目录
                itemMap.put(baseData.getId(), ti);// 只保存有目录的节点，不保存无叶子节点的节点。
            }
        }
    }

    void initMenuItems(Menu menu) ...{
        // 实现右键添加节点删除节点
        // final MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
        //
        // menuItem.setText("(&N)挂在同级节点");
        // menuItem.addListener(SWT.Selection, new Listener() {
        // public void handleEvent(Event e) {
        //
        // SubVO svo = (SubVO) tree.getSelection()[0].getData();
        // if (svo.getId() != "0") {
        //
        // // 如果多选，则在最前一个节点添加
        // if (tree.getSelection().length == 0)
        // return;
        // TreeItem newItem;
        // if (tree.getSelection()[0].getParentItem() == null) {
        // newItem = new TreeItem(tree.getSelection()[0]
        // .getParent(), SWT.NONE);
        // } else {
        // newItem = new TreeItem(tree.getSelection()[0]
        // .getParentItem(), SWT.NONE);
        // }
        // newItem.setText(new String[] { "新增会计科目" });
        // SubVO vo = new SubVO();
        // vo.setAsid("1001");
        // String id=KeyGenerator.generateStringID();
        // vo.setId(id);
        // SubVO pvo = (SubVO) newItem.getParentItem().getData();
        //                    
        // pvo.setSubtype("1");//把父节点记录为目录
        // // 只要修改了VO属性，就要在modifyList里面替换新的VO.
        //                    
        // if(pvo.getId()!="0" && !modifyList.contains(pvo)&&
        // !newList.contains(pvo)){
        // modifyList.add(pvo);
        // }
        //                    
        // vo.setSubpid(pvo.getId());
        // vo.setSubtype("0");
        // vo.setSubpath(pvo.getSubpath()+","+id);
        // vo.setSubName("新增会计科目");
        // System.out.println(vo.getSubName()+vo.getSubpath());
        // newItem.setData(vo);
        // tree.showItem(newItem);
        // newList.add(vo);
        // }
        // }
        // });
        // final MenuItem newSubItem = new MenuItem(menu, SWT.PUSH);
        // newSubItem.setText("(&M)挂在同级子节点");
        // newSubItem.addListener(SWT.Selection, new Listener() {
        // public void handleEvent(Event e) {
        // // 如果多选，则在最前一个节点添加
        // if (tree.getSelection().length == 0)
        // return;
        // TreeItem newItem = new TreeItem(tree.getSelection()[0],
        // SWT.NONE);
        // newItem.setText(new String[] { "新增子会计科目" });
        // SubVO vo = new SubVO();
        // vo.setAsid("1001");
        // String id=KeyGenerator.generateStringID();
        // vo.setId(id);
        // SubVO pvo = (SubVO) newItem.getParentItem().getData();
        // pvo.setSubtype("1");//把父节点记录为目录
        //                
        // //只要修改了VO属性，就要在modifyList里面替换新的VO.
        // if(pvo.getId()!="0" &&!modifyList.contains(pvo) &&
        // !newList.contains(pvo)){
        // modifyList.add(pvo);
        // }
        //                
        // vo.setSubpid(pvo.getId());
        //                
        // vo.setSubtype("0");
        // vo.setSubpath(pvo.getSubpath()+","+id);
        // vo.setSubName("新增子会计科目");
        // System.out.println(vo.getSubName()+vo.getSubpath());
        // newItem.setData(vo);
        // tree.showItem(newItem);
        // newList.add(vo);
        // }
        // });
        final MenuItem deleteItem = new MenuItem(menu, SWT.PUSH);
        deleteItem.setText("(&D)删除节点");
        deleteItem.addListener(SWT.Selection, new Listener() ...{
            public void handleEvent(Event e) ...{
                // 不是会计科目的，即挂上去的可以删除
                delete();
            }
        });

        // 添加分隔条
        new MenuItem(menu, SWT.SEPARATOR);
        final MenuItem saveAllItems = new MenuItem(menu, SWT.PUSH);
        saveAllItems.setText("(&S)保存");
        saveAllItems.addListener(SWT.Selection, new Listener() ...{
            public void handleEvent(Event e) ...{
                if (newList.size() > 0 || modifyList.size() > 0
                        || deleteList.size() > 0) ...{

                    save();
                }

            }
        });

        // 弹出菜单时，控制按钮是否可用。
        menu.addListener(SWT.Show, new Listener() ...{

            public void handleEvent(Event arg0) ...{
                if (newList.size() > 0 || modifyList.size() > 0
                        || deleteList.size() > 0) ...{
                    saveAllItems.setEnabled(true);
                } else ...{
                    saveAllItems.setEnabled(false);
                }
            }

        });

    }

    /** *//**
     * 删除
     * 
     * 2006-9-21 下午03:16:56
     */
    void delete() ...{
        MessageBox mb = new MessageBox(shell, SWT.ICON_QUESTION | SWT.OK
                | SWT.CANCEL);
        mb.setText("是否删除？");
        mb.setMessage("确认要删除该节点及所有叶子节点吗?");
        int rc = mb.open();
        if (rc == SWT.OK) ...{
            TreeItem[] treeItems = tree.getSelection();
            for (int i = 0; i < treeItems.length; i++) ...{
                RelSubVO o = (RelSubVO) treeItems[i].getData("SetSubData");// 保存删除的ID到deleteList
                if (!newList.contains(o)) ...{// 如果不是刚新增的条目，而是数据库中存在的。
                    deleteList.add(o);
                    delete(treeItems[i]);// 删除刚新增但没有保存到数据库中的。
                } else ...{ // 如果是刚新增的条目,而没有保存到数据库中的，在newList中删除。
                    newList.remove(o);
                    delete(treeItems[i]);// 删除刚新增但没有保存到数据库中的。
                }

                treeItems[i].dispose();
                // sum(null, 3);
            }
        }
    }

    // 递归删除方法。
    void delete(TreeItem item) ...{
        TreeItem[] treeItems = item.getItems();
        if (treeItems.length == 0) ...{
            return;
        }
        for (int i = 0; i < treeItems.length; i++) ...{
            delete(treeItems[i]);
            if (newList.contains(treeItems[i].getData("SetSubData"))) ...{
                newList.remove(treeItems[i].getData("SetSubData"));
            } else ...{
                deleteList.add(treeItems[i].getData("SetSubData"));
            }
            treeItems[i].dispose();
        }
    }

    /** *//**
     * 保存数据。newList， modifyList , deleteList
     */
    private void save() ...{
        System.out.println("newList::" + newList.size());
        for (int i = 0; i < newList.size(); i++) ...{
            RelSubVO vo = (RelSubVO) newList.get(i);
            System.out.println("new vo::" + vo.getId() + "  " + vo.getName()
                    + "  " + vo.getPath());
        }
        System.out.println("modifyList::" + modifyList.size());
        for (int i = 0; i < modifyList.size(); i++) ...{
            RelSubVO vo = (RelSubVO) modifyList.get(i);
            System.out.println("new vo::" + vo.getId() + "  " + vo.getName()
                    + "  " + vo.getPath());
        }
        System.out.println("deleteList::" + deleteList.size());
        for (int i = 0; i < deleteList.size(); i++) ...{
            RelSubVO vo = (RelSubVO) deleteList.get(i);
            System.out.println("new vo::" + vo.getId() + "  " + vo.getName()
                    + "  " + vo.getPath());
        }
        mapSave.put("newList", newList);
        mapSave.put("modifyList", modifyList);
        mapSave.put("deleteList", deleteList);
        Object obj = SWTDataViewUtil.parseObject(mapSave, "saveRelSub");
        MessageBox mb = new MessageBox(shell, SWT.OK);
        mb.setText("提示");
        if (obj != null)
            mb.setMessage((String) obj);
        mb.open();
        newList.clear();
        modifyList.clear();
        deleteList.clear();
    }

}