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

package com.gs3.testGXT.client.tree;

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

import com.gs3.testGXT.client.Keys.FileSystemKey;
import com.sencha.gxt.data.shared.TreeStore;
import com.sencha.gxt.data.shared.TreeStore.TreeNode;
import com.sencha.gxt.dnd.core.client.TreeDropTarget;
import com.sencha.gxt.widget.core.client.box.AlertMessageBox;
import com.sencha.gxt.widget.core.client.button.TextButton;
import com.sencha.gxt.widget.core.client.event.SelectEvent;
import com.sencha.gxt.widget.core.client.event.SelectEvent.SelectHandler;
import com.sencha.gxt.widget.core.client.tree.Tree;

//NOTE: the non-merge version of this is saved in the first git commit
public class MyTreeDropTarget extends TreeDropTarget<FileSystemKey> {
    private TextButton btYes= new TextButton("Yes");;
    private TextButton btYesToAll = new TextButton("Yes to All");
    private TextButton btNo = new TextButton("No");
    private TextButton btCancel = new TextButton("Cancel");
    private TextButton btNoToAll = new TextButton("No to All");
    private AlertMessageBox ctMsg= new AlertMessageBox("", "");;

    private boolean acceptable; //tag for if duplicate keys found
    private boolean dropOnRoot;
    //recovery items for when merge mode is enabled
    private LinkedList<KeyIndex> itemsToAdd = new LinkedList<KeyIndex>();   
    private LinkedList<KeyIndex> conflicts  = new LinkedList<KeyIndex>();

    private void createMergeWarn(String key1, String key2, int len) {
        String heading = "Warning: " + len + " conflicting item";
        if(len > 1)
            heading += "s";
        
        ctMsg.setHeading(heading);
        
        String message = "The file '" + key2 + "' already exists in the destination folder '" + key1 + "'. Overwrite it?";
        if(--len > 1) {
            message += " (" + len + " more conflicts...)";
        }
        else if (len == 1) {
            message += " (1 more conflict...)";
        }
        
        ctMsg.setMessage(message);
        ctMsg.setHeight(150);
        ctMsg.show();       
    }

    public MyTreeDropTarget(Tree<FileSystemKey, ?> tree, boolean dropOnRoot) {
        super(tree);
        
        this.dropOnRoot = dropOnRoot;
        //choose to replace the current file
        btYes.addSelectHandler(new SelectHandler() {
            @Override
            public void onSelect(SelectEvent event) {
                itemsToAdd.add(conflicts.poll());
                if(conflicts.size() == 0) {
                    ctMsg.hide();
                    InsertClonesFromList();
                }
                else {
                    createMergeWarn(conflicts.get(0).item.Key1(), conflicts.get(0).item.Key2(), conflicts.size());
                }
            }
        });

        //chose to replace all the current files
        btYesToAll.addSelectHandler(new SelectHandler() {
            @Override
            public void onSelect(SelectEvent event) {
                ctMsg.hide();
                itemsToAdd.addAll(conflicts);
                conflicts = new LinkedList<KeyIndex>();
                InsertClonesFromList();
            }
        });
        
        //chose not to replace the current file
        btNo.addSelectHandler(new SelectHandler() {
            public void onSelect(SelectEvent event) {
                conflicts.poll();
                if(conflicts.size() == 0) {
                    ctMsg.hide();
                    InsertClonesFromList();
                }
                else {
                    createMergeWarn(conflicts.get(0).item.Key1(), conflicts.get(0).item.Key2(), conflicts.size());
                }
            }
        });
        
        //choose not to replace any files
        btNoToAll.addSelectHandler(new SelectHandler() {
            @Override
            public void onSelect(SelectEvent event) {
                ctMsg.hide();
                conflicts = new LinkedList<KeyIndex>();
                InsertClonesFromList(); 
            }
        });
        
        
        //cancel to current operation, will have zero side-effects
        btCancel.addSelectHandler(new SelectHandler() {
            @Override
            public void onSelect(SelectEvent event) {
                ctMsg.hide();
                conflicts = new LinkedList<KeyIndex>();
                itemsToAdd = new LinkedList<KeyIndex>();
            }
        });

        //disable all of the predefined buttons on the item
        ctMsg.setPredefinedButtons();
        ctMsg.addButton(btYes);
        ctMsg.addButton(btYesToAll);
        ctMsg.addButton(btNo);
        ctMsg.addButton(btNoToAll);
        ctMsg.addButton(btCancel);
    }

    //TODO: actual file operations
    private void InsertClonesFromList() {
        //itemsToAdd is the only list we need
        TreeStore<FileSystemKey> ts = getWidget().getStore();
        for(KeyIndex ki : itemsToAdd) {
            if(ki.replace) {
                ts.remove(ki.item);     
            }
            
            //always insert at index 0: the tree will be sorted later
            if(ki.parent == null) {
                ts.insert(0, ki.item);
            }
            else {
                ts.insert(ki.parent, 0, ki.item); 
            }
            
            ts.update(ki.item);               //forces item visibility
        }
        
        itemsToAdd = new LinkedList<KeyIndex>();
        conflicts = new LinkedList<KeyIndex>();
    }
    
    
    @Override
    protected void appendModel(FileSystemKey p, List<?> items, int index) {
        if (items.size() == 0)
            return;
        if (items.get(0) instanceof TreeStore.TreeNode) {
            @SuppressWarnings("unchecked")
            List<TreeStore.TreeNode<FileSystemKey>> nodes = (List<TreeStore.TreeNode<FileSystemKey>>) items;

            if(p == null != dropOnRoot)
                return;
            acceptable = true;          
            
            checkMergeModel(p, nodes, false);

            if(acceptable) { //zero duplicates contained in the items to insert 
                InsertClonesFromList();
            } else { //we have a bit of confirmation/denial to do       
                createMergeWarn(conflicts.get(0).item.Key1(), conflicts.get(0).item.Key2(), conflicts.size());
            }
        } else { // we should NEVER end up getting this unless we have items
            // coming from another type of chart
            @SuppressWarnings("unchecked")
            List<FileSystemKey> models = (List<FileSystemKey>) items;
            if (p == null) {
                getWidget().getStore().insert(index, models);
            } else {
                getWidget().getStore().insert(p, index, models);
            }
        }
    }   

    //I think I'm making a mistake here...
    @SuppressWarnings("unchecked")
    private void checkMergeModel(FileSystemKey parent,
            List<TreeStore.TreeNode<FileSystemKey>> items, boolean succ) {
        for (TreeStore.TreeNode<FileSystemKey> node : items) {
            
            //don't allow shortcuts, or entire filesystem, to be dropped into right hand side
            if(!node.getData().Droppable()) {
                continue;
            }
            FileSystemKey clone;
            // slightly different handling for if this item is at a root or a
            // branch of the tree
            if (parent == null) {
                clone = new FileSystemKey(node.getData());
                clone.SetKey("/", null, null);
            } else {
                clone = new FileSystemKey(node.getData());
                clone.SetKey(parent.toKey(), null, null);
            }

            if (!succ && getWidget().getStore().findModel(clone) != null) { 
                // key is a duplicate -> need to do some merging
                if(!getWidget().isLeaf(clone)) { 
                    //the item itself is already in the tree, and must itself be a folder,
                    //so we don't actually add it to the list of items
                    //we still need to add all of it's children though
                    checkMergeModel(clone, (List<TreeNode<FileSystemKey>>) node.getChildren(), succ);
                }
                else { //item is leaf
                    //the item is being merged-replaced, but only if the user wants this - we should have a confirmation dialog for all of these
                    //this also means no more recursion beyond this point
                    conflicts.add(new KeyIndex(clone, parent, true));
                    acceptable = false;
                }
            } else {
                itemsToAdd.add(new KeyIndex(clone, parent, false));
                List<TreeStore.TreeNode<FileSystemKey>> children = (List<TreeStore.TreeNode<FileSystemKey>>) node
                        .getChildren();
                checkMergeModel(clone, children, true);
            }
        }
    }

    private class KeyIndex {
        public FileSystemKey item;
        public FileSystemKey parent;
        public boolean replace; 
        public KeyIndex(FileSystemKey item, FileSystemKey parent, boolean replace) {
            this.item = item;
            this.parent = parent;
            this.replace = replace;
        }
    }
    
    
}