source: other-projects/FileTransfer-WebSocketPair/testGXTWithGreenstone/src/com/gs3/testGXT/client/tree/MyLocalFileSystemTree.java@ 33053

package com.gs3.testGXT.client.tree;

import java.util.ArrayList;
import java.util.LinkedList;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.gs3.testGXT.client.Keys.FileSystemKey;
import com.gs3.testGXT.client.services.ListDirectoryService;
import com.gs3.testGXT.client.services.ListDirectoryServiceAsync;
import com.sencha.gxt.core.client.ValueProvider;
import com.sencha.gxt.data.shared.TreeStore;
import com.sencha.gxt.widget.core.client.box.AlertMessageBox;
import com.sencha.gxt.widget.core.client.event.BeforeExpandItemEvent;
import com.sencha.gxt.widget.core.client.event.BeforeExpandItemEvent.BeforeExpandItemHandler;
import com.sencha.gxt.widget.core.client.tree.Tree;

public class MyLocalFileSystemTree extends Tree<FileSystemKey, FileSystemKey> {
    protected ListDirectoryServiceAsync listDirService = null;
    AsyncCallback<LinkedList<String[]>> callback = null;
    
    public MyLocalFileSystemTree(MyTreeStoreExt store,
            ValueProvider<? super FileSystemKey, FileSystemKey> valueProvider) {
        super(store, valueProvider);
        this.addBeforeExpandHandler(new myOtherBeforeExtendHandler(store));
        
        listDirService = GWT.create(ListDirectoryService.class);
    }
    
    class myOtherBeforeExtendHandler implements BeforeExpandItemHandler<FileSystemKey> {
        TreeStore<FileSystemKey> ts;
        public myOtherBeforeExtendHandler(TreeStore<FileSystemKey> ts) {
            this.ts = ts;
        }

        @Override
        public void onBeforeExpand(BeforeExpandItemEvent<FileSystemKey> event) {
            final FileSystemKey parent = event.getItem();
            if(!parent.Walked()) {
                final String key = parent.toKey();
                final String path = parent.toPath();
                ts.removeChildren(parent);
                
                callback = new AsyncCallback<LinkedList<String[]>>() {
                    public void onFailure(Throwable caught) {
                        AlertMessageBox amb = new AlertMessageBox("Error", "Error: " + caught.getMessage()); //TODO: this is going to be messy - fix
                        amb.show();
                    }

                    public void onSuccess(LinkedList<String[]> result) {
                        updateStore(result, ts, parent, key, path);
                        parent.setWalked();
                    }
                };
                
                listDirService.getDirectoryContents(path, callback);
            }
        }
    }
    
    public void refreshTree(FileSystemKey k) {
        if(store instanceof MyTreeStoreExt) {
            ((MyTreeStoreExt)store).Refresh(k, this);
        }       
    }

    private void updateStore(LinkedList<String[]> result, TreeStore<FileSystemKey> ts, FileSystemKey parent, String key, String path) {
        ArrayList<FileSystemKey> keylist = new ArrayList<FileSystemKey>(result.size());
        for(String[] set : result) {
            //structure: 
            //  File/Folder
            //  Name
            //  Canonical Path
            FileSystemKey child = null;
            if(set[0].equals("File")) {
                child = new FileSystemKey(key, set[1], false, true, set[2]); //key, name, file, realized, path
            }
            else if (set[0].equals("Folder")) {
                child = new FileSystemKey(key, set[1], true, false, set[2]); //key, name, folder, not realized, path
            }
            keylist.add(child);
        }
        ts.add(parent, keylist);
        //ts.update(parent);
    }

    @Override
    protected boolean hasChildren(FileSystemKey model) {
        // This will control the leaf behavior: true for looking like a folder and false to look like an item
        return model.isFolder();
    }
}