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

package com.gs3.testGXT.client.tree;

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

import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Style.Cursor;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Element;
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.data.shared.ModelKeyProvider;
import com.sencha.gxt.data.shared.SortDir;
import com.sencha.gxt.data.shared.Store;
import com.sencha.gxt.data.shared.TreeStore;
import com.sencha.gxt.widget.core.client.box.AlertMessageBox;

/**
 * A {@link Store} for hierarchical data. Parent-Child relationships are tracked
 * internally, and can be accessed through the {@link #getParent(Object)} and
 * {@link #getChildren(Object)} calls, and modified through the many add()
 * overrides or the {@link #remove(Object)} method.
 * 
 * As with {@link ListStore}, all changes and data are relative to what is
 * currently visible, due to the {@link Store.StoreFilter}s. As such, if filters
 * are active and structural changes are required, it might be necessary to
 * disable filters to make the change, re-enabling them when finished.
 * 
 * @param <FileSystemKey>
 *            the model type
 */
public class MyTreeStoreExt extends TreeStore<FileSystemKey> {

    protected ListDirectoryServiceAsync listDirService = null;
    AsyncCallback<LinkedList<String[]>> callback = null;


    public MyTreeStoreExt(ModelKeyProvider<? super FileSystemKey> keyProvider) {
        super(keyProvider);

        StoreSortInfo<FileSystemKey> info = new StoreSortInfo<FileSystemKey>(FileSystemKey.getComparator(), SortDir.ASC);
        this.addSortInfo(info);

        listDirService = GWT.create(ListDirectoryService.class);
    }

    public void Refresh(final FileSystemKey fsk, final MyLocalFileSystemTree tree) {
        final String key = fsk.toKey();
        final String path = fsk.toPath();
        
        final boolean wasExpanded = fsk.isFolder() && tree.isExpanded(fsk);

        AsyncCallback<LinkedList<String[]>> 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) {
                
                //no need for this check I think
                if(fsk.isFolder()) {
                    conservativeUpdateChildren(result, fsk, key, path, tree);
                    
                    fsk.setWalked();
                    tree.setExpanded(fsk, wasExpanded);             
                }
            }
        };

        listDirService.getDirectoryContents(fsk.toPath(), callback);
    }


    //essentially just recursive descent model checking
    private void conservativeUpdateChildren(LinkedList<String[]> result, FileSystemKey parent, String key, String path, final MyLocalFileSystemTree tree) {     
        List<FileSystemKey> children = this.getChildren(parent);
        ArrayList<FileSystemKey> itemsToAdd = new ArrayList<FileSystemKey>();
        ArrayList<FileSystemKey> itemsToRefresh = new ArrayList<FileSystemKey>();
        ArrayList<FileSystemKey> itemsToRemove = new ArrayList<FileSystemKey>();

        itemsToRemove.addAll(children);

        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
            }

            //AlertMessageBox test = new AlertMessageBox("test", "test: " + children.size());
            //test.show();

            int ind;
            if((ind = children.indexOf(child)) == -1) {
                //then we add the item
                itemsToAdd.add(child);
            }
            else {
                child = children.get(ind);
                if(child.Walked()) {//only update items that we expect to be up to date anyway
                    itemsToRefresh.add(child);
                }

                //the item already exists - we should remove it from our list of exclusions
                itemsToRemove.remove(child);
            }       
        }

        /*delete all items that were removed from the set - 
         * we know this because they didn't show up in the list of items from the server*/
        for(FileSystemKey child : itemsToRemove) {
            remove(child);

            //we should probably do some sort of check here
        }

        add(parent, itemsToAdd);

        for(FileSystemKey f: itemsToRefresh) {
            Refresh(f, tree);
        }
    }

    //this is the bad of way of doing this - it is preserved just incase there is some issue with the good way
    private void updateChildren(LinkedList<String[]> result, 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);
        }
        add(parent, keylist);
    }
}