Here my third try: This way is recommended by gwt-commiter.
Please see following issue: 
http://code.google.com/p/google-web-toolkit/issues/detail?id=7160

Current status:
* Adding is possible
* Removing is possible if not last child!

So, last open point, refresh the tree if last open child!

package com.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import com.google.gwt.cell.client.AbstractCell;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.safehtml.shared.SafeHtmlBuilder;
import com.google.gwt.user.cellview.client.CellTree;
import com.google.gwt.user.client.ui.AbsolutePanel;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.view.client.ListDataProvider;
import com.google.gwt.view.client.SingleSelectionModel;
import com.google.gwt.view.client.TreeViewModel;

public class MyCelltreeTest2 implements EntryPoint {
        private AbsolutePanel absolutePanel;
        private CellTree cellTree;
        private Button btnAdd;
        private Button btnRemove;
        private MyTreeModel myTreeModel;
        private SingleSelectionModel<MyNode> selectionModelCellTree =
null;
        private Map<MyNode, ListDataProvider<MyNode>> mapDataProviders
= null;
        private ListDataProvider<MyNode> rootDataProvider = null;

        public void onModuleLoad() {
                RootPanel rootPanel = RootPanel.get();
                rootPanel.add(getAbsolutePanel(), 0, 0);
        }

        private AbsolutePanel getAbsolutePanel() {
                if (absolutePanel == null) {
                        absolutePanel = new AbsolutePanel();
                        absolutePanel.setSize("612px", "482px");
                        absolutePanel.add(getCellTree(), 0, 0);
                        absolutePanel.add(getBtnAdd(), 265, 428);
                        absolutePanel.add(getBtnRemove(), 336, 428);
                }
                return absolutePanel;
        }
        private CellTree getCellTree() {
                if (cellTree == null) {
                        myTreeModel = new MyTreeModel();
                        cellTree = new CellTree(myTreeModel, null);
                        cellTree.setSize("285px", "401px");
                }
                return cellTree;
        }
        private Button getBtnAdd() {
                if (btnAdd == null) {
                        btnAdd = new Button("Add");
                        btnAdd.addClickHandler(new ClickHandler() {
                                public void onClick(ClickEvent event)
{

                                        MyNode node =
selectionModelCellTree.getSelectedObject();
//                                      if(node != null)
                                                myTreeModel.add(node,
"Bla");
                                }
                        });
                }
                return btnAdd;
        }
        private Button getBtnRemove() {
                if (btnRemove == null) {
                        btnRemove = new Button("Remove");
                        btnRemove.addClickHandler(new ClickHandler() {
                                public void onClick(ClickEvent event)
{

                                        MyNode node =
selectionModelCellTree.getSelectedObject();
//                                      if(node != null)
 
myTreeModel.remove(node);
                                }
                        });
                }
                return btnRemove;
        }


        public class MyNode {

            private String name;
            private ArrayList<MyNode> childs; //nodes childrens
            private MyNode parent; //track internal parent


            public MyNode(String name) {
                super();
                parent = null;
                this.name = name;
                childs = new ArrayList<MyNode>();
            }
            public boolean hasChildrens() {
                return childs.size()>0;
            }
            public ArrayList<MyNode> getList() {
                return childs;
            }
            public MyNode getParent() {
                return parent;
            }

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

        public class MyTreeModel implements TreeViewModel {


            public MyTreeModel() {
                selectionModelCellTree = new
SingleSelectionModel<MyNode>();
                mapDataProviders = new HashMap<MyCelltreeTest2.MyNode,
ListDataProvider<MyNode>>();
            }

            public void add(MyNode myparent, String name) {

                MyNode child = new MyNode(name);

                //root-node
                if(myparent == null){
                        rootDataProvider.getList().add(child);
                        mapDataProviders.put(child, rootDataProvider);
                }
                else{

                        ListDataProvider<MyNode> dataprovider =
mapDataProviders.get(myparent);
                        myparent.childs.add(child);
                        child.parent = myparent;
                        dataprovider.refresh();
                }
            }
            public void remove(MyNode objToRemove) {

                        ListDataProvider<MyNode> dataprovider =
mapDataProviders.get(objToRemove);
                        dataprovider.getList().remove(objToRemove);
//                      mapDataProviders.remove(objToRemove);
                        dataprovider.refresh();
                        dataprovider.flush();

                        if(objToRemove.parent != null){
                                ListDataProvider<MyNode>
dataproviderParent = mapDataProviders.get(objToRemove.parent);
 
objToRemove.parent.childs.remove(objToRemove);
                                dataproviderParent.refresh();
                                dataproviderParent.flush();
                        }
                        else{
                                rootDataProvider.refresh();
                                rootDataProvider.flush();
                        }
            }

//          public void remove(MyNode objToRemove) {
//
//
//                      ListDataProvider<MyNode> dataprovider =
mapDataProviders.get(objToRemove);
//
//                      List<MyNode> alNodes =
dataprovider.getList();
//                      alNodes.remove(objToRemove);
//                      dataprovider.setList(alNodes);   <-- try with
setList
//                      mapDataProviders.remove(objToRemove);
//                      dataprovider.refresh();
//                      dataprovider.flush();
//
//                      if(objToRemove.parent != null){
//                              ListDataProvider<MyNode>
dataproviderParent = mapDataProviders.get(objToRemove.parent);
//
objToRemove.parent.childs.remove(objToRemove);
//                              dataproviderParent.refresh();
//                              dataproviderParent.flush();
//                      }
//                      else{
//                              rootDataProvider.refresh();
//                              rootDataProvider.flush();
//                      }
//          }

            @Override
            public <T> NodeInfo<?> getNodeInfo(T value) {

                if (value == null) { // root is not set
                    rootDataProvider = new
ListDataProvider<MyNode>(new ArrayList<MyNode>());
                        MyCell cell = new MyCell();
                    return new
DefaultNodeInfo<MyNode>(rootDataProvider, cell,
selectionModelCellTree, null);
                } else {
                        MyNode myValue = (MyNode) value;
                    ListDataProvider<MyNode> dataProvider = new
ListDataProvider<MyNode>(myValue.childs);
                        MyCell cell = new MyCell();
                        for(MyNode currentNode : myValue.childs){
                                mapDataProviders.put(currentNode,
dataProvider);
                        }
                    return new DefaultNodeInfo<MyNode>(dataProvider,
cell, selectionModelCellTree, null);
                }
            }

            @Override
            public boolean isLeaf(Object value) {
                if (value instanceof MyNode) {
                    MyNode t = (MyNode) value;
                    if (!t.hasChildrens())
                        return true;
                    return false;
                }
                return false;
            }

        }

        public class MyCell extends AbstractCell<MyNode> {
                public MyCell() {
                  super();
                }
                @Override
                public void render(Context context, MyNode value,
SafeHtmlBuilder sb) {
                  if (value == null) {
                    return;
                  }
                  sb.appendEscaped(value.getName());
                }
        }
}

-- 
You received this message because you are subscribed to the Google Groups 
"Google Web Toolkit" group.
To post to this group, send email to google-web-toolkit@googlegroups.com.
To unsubscribe from this group, send email to 
google-web-toolkit+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/google-web-toolkit?hl=en.

Reply via email to