* Copyright (c) 2000, 2005 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

* File Viewer example

*/

  public static final String ID_FILEEXPLORER = "org.cfeclipse.cfml.views.explorer.vfs.view.VFSView";

  private static final String RESOURCE_BUNDLE= VFSView.class.getName();

  private static ResourceBundle resourceBundle= ResourceBundle.getBundle(RESOURCE_BUNDLE);

  private final static String DRIVE_A = "a:" + FileName.SEPARATOR;

  private static boolean initial = true;

  

  /* UI elements */  

  private Display display;

  private Shell shell;

  private Label numObjectsLabel;

  private Label diskSpaceLabel;

 

  /* currently selected directory */

  private FileObject currentDirectory = null;

 

  /* Drag and drop optimizations */

  private boolean isDragging = false; // if this app is dragging

  private boolean isDropping = false; // if this app is dropping

//  private FileObject[]  processedDropFiles = null; // so Drag only deletes what it needs to

  private FileObject[]  deferredRefreshFiles = null;      // to defer notifyRefreshFiles while we do DND

  private boolean deferredRefreshRequested = false; // to defer notifyRefreshFiles while we do DND

  /* Combo view */

  private static final String COMBODATA_ROOTS = "Combo.roots";

    // File[]: Array of files whose paths are currently displayed in the combo

  private static final String COMBODATA_LASTTEXT = "Combo.lastText";

    // String: Previous selection text string

  private static final String COMBODATA_LASTCONNECTIONID = "Combo.lastConnectionId";

  // String: Previous connectionid

  private Combo combo;

  /* Tree view */

  static public ImageRegistry iconCache = CFPluginImages.getImageRegistry();

 

  public static final String TREEITEMDATA_FILE = "TreeItem.file";

    // File: File associated with tree item

  public static final String TREEITEMDATA_IMAGEEXPANDED = "TreeItem.imageExpanded";

    // Image: shown when item is expanded

  public static final String TREEITEMDATA_IMAGECOLLAPSED = "TreeItem.imageCollapsed";

    // Image: shown when item is collapsed

  private static final String TREEITEMDATA_STUB = "TreeItem.stub";

    // Object: if not present or null then the item has not been populated

  public static final String TREEITEMDATA_URI = "TreeItem.uri";

    // VFS URI associated with table row

  public static final String TREEITEMDATA_CONNECTIONID = "TableItem.connectionId";

    // connection id

  private static Tree tree;

  private Label treeScopeLabel;

  /* Table view */

  protected static final DateFormat dateFormat = DateFormat.getDateTimeInstance(

    DateFormat.MEDIUM, DateFormat.MEDIUM);

  public static final String TABLEITEMDATA_FILE = "TableItem.file";

    // File: File associated with table row

  public static final String TABLEDATA_DIR = "Table.dir";

    // File: Currently visible directory

  private static final int[] tableWidths = new int[] {150, 60, 75, 150};

    public static final String TABLEITEMDATA_CONNECTIONID = "Table.connectionId";

    protected static final String TABLEDATA_CONNECTIONID = "TableItem.connectionId";

  private final String[] tableTitles = new String [] {

    VFSView.getResourceString("table.Name.title"),

    VFSView.getResourceString("table.Size.title"),

    VFSView.getResourceString("table.Type.title"),

    VFSView.getResourceString("table.Modified.title")

  };

  private Table table;

 

  /* File Items Tabs */

  private TabItem tabFileItems;

 

  /* Table update worker */

  // Control data

  private final Object workerLock = new Object();

    // Lock for all worker control data and state

  private volatile Thread  workerThread = null;

    // The worker's thread

  private volatile boolean workerStopped = false;

    // True if the worker must exit on completion of the current cycle

  private volatile boolean workerCancelled = false;

    // True if the worker must cancel its operations prematurely perhaps due to a state update

  // Worker state information -- this is what gets synchronized by an update

  private volatile FileObject workerStateDir = null;

  // State information to use for the next cycle

  private volatile FileObject workerNextDir = null;

  // Comnnons VFS Manager

  private FileSystemManager fsManager = null;

  public TreeMap<String, FTPConnectionProperties> fConnections;

  private String currentConnectionId;

  private String workerNextConnectionId;

  protected String workerStateConnectionId;

  public Object fSourceConnectionId;

  private ConnectionAction connectionAction;

  private DeleteAction deleteAction;

  private CopyAction copyAction;

  private PasteAction pasteAction;

  private NewFolderAction newFolderAction;

  private NewFileAction newFileAction;

  //private static boolean VFS_DEBUG = System.getProperty("org.cfeclipse.cfml.views.explorer.vfs.debug") != null;

  private static boolean VFS_DEBUG = true;

     

  public static void error (String s) {

    if ( VFS_DEBUG )

      System.err.println(s);

  }

  public static void debug (Exception e) {

    if ( VFS_DEBUG )

      e.printStackTrace();

  }

 

  public Tree getTree () {

    return tree;

  }

 

  public Table getTable () {

    return table;

  }

 

  /**

   * Returns the Commons VFS File System Manager

   */

  public FileSystemManager getFileSystemManager ()

  {

    return fsManager;

  }

 

  /**

   * Closes the main program.

   */

  public void dispose() {

    workerStop();

    //return super.close();

  }

 

  /**

   * Returns a string from the resource bundle.

   * We don't want to crash because of a missing String.

   * Returns the key if not found.

   */

  public static String getResourceString(String key) {

    try {

      return resourceBundle.getString(key);

    } catch (MissingResourceException e) {

      return key;

    } catch (NullPointerException e) {

      return "!" + key + "!";

    }     

  }

  /**

   * Returns a string from the resource bundle and binds it

   * with the given arguments. If the key is not found,

   * return the key.

   */

  public static String getResourceString(String key, Object[] args) {

    try {

      return MessageFormat.format(getResourceString(key), args);

    } catch (MissingResourceException e) {

      return key;

    } catch (NullPointerException e) {

      return "!" + key + "!";

    }

  }

  /**

   * Returns a string from the resource bundle and binds it

   * with the given arguments. If the key is not found,

   * return the key.

   */

  public static String getResourceString(String key, Object arg) {

    try {

      return MessageFormat.format(getResourceString(key), new Object []{arg});

    } catch (MissingResourceException e) {

      return key;

    } catch (NullPointerException e) {

      return "!" + key + "!";

    }

  }

   

  /**

   * Returns a new menu manager for the window

   */

  protected MenuManager createMenuManager()

  {

    MenuManager menuManager = (MenuManager) getViewSite().getActionBars().getMenuManager();

    // File

    MenuManager fileMenu =new MenuManager(getResourceString("menu.File.text"));

    connectionAction = new FileMenu.ConnectionAction(this

        , getResourceString("menu.File.New.text")

        , getResourceString("menu.File.New.text") );

    fileMenu.add(connectionAction);

    deleteAction = new FileMenu.DeleteAction(this

        , getResourceString("menu.Connection.Delete.text")

        , getResourceString("menu.Connection.Delete.text") );

    fileMenu.add(deleteAction);

    newFolderAction = new FileMenu.NewFolderAction(this

        , getResourceString("menu.File.NewFolder.text")

        , getResourceString("menu.File.NewFolder.text"));

    fileMenu.add(newFolderAction);

   

    newFileAction = new FileMenu.NewFileAction(this

        , getResourceString("menu.File.NewFile.text")

        , getResourceString("menu.File.NewFile.text"));

    fileMenu.add(newFileAction);

    // Edit

    MenuManager editMenu =new MenuManager(getResourceString("menu.Edit.text"));

    copyAction = new EditMenu.CopyAction(this

        , getResourceString("menu.Edit.copy.text")

        , getResourceString("menu.Edit.copy.text") );

    editMenu.add(copyAction);

   

    pasteAction = new EditMenu.PasteAction(this

        , getResourceString("menu.Edit.paste.text")

        , getResourceString("menu.Edit.paste.text"));

    editMenu.add(pasteAction);

   

   

    menuManager.add(fileMenu);

    menuManager.add(editMenu);

    // hook the tree context menu

    MenuManager menuMgr = new MenuManager("#PopupMenu");

    menuMgr.setRemoveAllWhenShown(true);

    menuMgr.addMenuListener(new IMenuListener() {

      public void menuAboutToShow(IMenuManager manager) {

        VFSView.this.fillContextMenu(manager,new Action[]{connectionAction,deleteAction,copyAction,pasteAction,newFolderAction,newFileAction});

      }

    });

    Menu menu = menuMgr.createContextMenu(tree);

    tree.setMenu(menu);

    // hook the table context menu

    MenuManager tabMenuMgr = new MenuManager("#PopupMenu");

    tabMenuMgr.setRemoveAllWhenShown(true);

    tabMenuMgr.addMenuListener(new IMenuListener() {

      public void menuAboutToShow(IMenuManager manager) {

        VFSView.this.fillContextMenu(manager,new Action[]{copyAction,pasteAction,newFolderAction,newFileAction});

      }

    });

    Menu tabMenu = tabMenuMgr.createContextMenu(table);

    table.setMenu(tabMenu);

   

    return menuManager;

  }

    private void fillContextMenu(IMenuManager manager,Action[] actions) {

    //Somehow we have to know what this item is

      for(Action action:actions) {       

        manager.add(action);

      }   

  }

 

   /**

     * Helper method to calculate the size of the cool item

     *

     * @param item the cool item

     */

  private void calcSize(CoolItem item) {

      Control control = item.getControl();

      Point pt = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);

      pt = item.computeSize(pt.x, pt.y);

      item.setSize(pt);

  }

 

  /**

   * Construct the UI

   *

   * @param container the ShellContainer managing the Shell we are rendering inside

   */

    public void createPartControl(Composite parent)

  {

      display = parent.getDisplay();

    shell = getSite().getShell();

    fConnections = VFSUtil.loadFileSystems();

    try {

      fsManager = VFS.getManager();

    } catch (FileSystemException e) {

      // TODO Auto-generated catch block

      e.printStackTrace();

    }

    Composite container = new Composite(parent, SWT.NONE);

    container.setLayout(new GridLayout(1, true));

   

    GridData gridData = new GridData(GridData.FILL_HORIZONTAL);

    gridData.grabExcessHorizontalSpace = true;

   

    CoolBar coolbar = new CoolBar(container, SWT.NONE);

    coolbar.setLayoutData(gridData);

      // Create a toolbar coolitem

    final CoolItem item1 = new CoolItem(coolbar, SWT.NONE);

      item1.setControl(createToolBar(coolbar));

      calcSize(item1);

   

    // Create a combo coolitem

    gridData = new GridData(GridData.FILL_HORIZONTAL);

    gridData.widthHint = 185;

   

      final CoolItem item2 = new CoolItem(coolbar, SWT.NONE);

      item2.setControl(createComboView(coolbar, gridData));

      calcSize(item2);

     

    SashForm sashForm = new SashForm(container, SWT.NONE);

    sashForm.setOrientation(SWT.VERTICAL);

   

    gridData = new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL);

    sashForm.setLayoutData(gridData);

   

    createTreeView(sashForm);

    createTableView(sashForm);

   

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

    Composite container1 = new Composite(container, SWT.NONE);

    container1.setLayout(new GridLayout(2, true));

    container1.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false));

    numObjectsLabel = new Label(container1, SWT.BORDER);

    numObjectsLabel.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));// gridData);

    diskSpaceLabel = new Label(container1, SWT.BORDER);

    diskSpaceLabel.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true)); //gridData);

    createMenuManager();

    try {

      notifyRefreshFiles(null);

    } catch (Exception e) {

      debug (e);

    }

    //return container;

  }

 

 

  /**

   * Creates the toolbar

   *

   * @param shell the shell on which to attach the toolbar

   * @param layoutData the layout data

   */

  private Control createToolBar(final Composite shell) { //, Object layoutData) {

    final ToolBar toolBar = new ToolBar(shell, SWT.FLAT);

   

    // New VFS

    ToolItem item = new ToolItem(toolBar, SWT.PUSH);

    item.setImage(iconCache.get(CFPluginImages.ICON_DRIVE_FTP));//.iconFile]);

    //item.setText(getResourceString("tool.New.vfs.text"));

    item.setToolTipText(getResourceString("tool.New.vfs.tip"));

   

    item.addSelectionListener(new SelectionAdapter () {

      public void widgetSelected(SelectionEvent e)

      {

        connectionAction.run();

      }

    });

    // Home

    item = new ToolItem(toolBar, SWT.PUSH);

    item.setImage(iconCache.get(CFPluginImages.ICON_HOME));

    //item.setText(getResourceString("tool.home.text"));

    item.setToolTipText(getResourceString("tool.home.tip"));

   

    item.addSelectionListener(new SelectionAdapter () {

      public void widgetSelected(SelectionEvent e)

      {

        try {

          // Jump the file system home directory, some FS don't have homes

         

          String homeDir   = getCurrentDirectory().getName().getScheme().equals("file")

              ? VFSUtil.USER_HOME

              : (String)getCurrentDirectory().getFileSystem().getAttribute("HOME_DIRECTORY");

         

          // Build a URI from the home dir

          String uri   = Os.isFamily(Os.OS_FAMILY_UNIX)

                ? getCurrentDirectory().getName().getRootURI() + homeDir

                : getCurrentDirectory().getName().getScheme() + ":///" + homeDir.replace('\\','/');

               

          FileObject fo  = resolveURI(uri,getCurrentConnectionId());

         

          if ( fo.exists() )

            notifySelectedDirectory(fo, getCurrentConnectionId());

          else

            VFSUtil.MessageBoxInfo(getResourceString("error.jump.home", new Object[] {homeDir} ));

         

        } catch (FileSystemException ex) {

          FileObject fo;

          try {

            fo = resolveURI(fConnections.get(getCurrentConnectionId()).getURI().toString(),getCurrentConnectionId());

            if ( fo.exists() )

              notifySelectedDirectory(fo, getCurrentConnectionId());

            else

              VFSUtil.MessageBoxInfo(getResourceString("error.jump.home", new Object[] {fo.getURL().toString()} ));

          } catch (FileSystemException e1) {

            VFSUtil.MessageBoxInfo(ex.getMessage());

          }

        }

      }

    });

   

    // New folder

    item = new ToolItem(toolBar, SWT.PUSH);

    item.setImage(iconCache.get(CFPluginImages.ICON_FOLDER_NEW));

    //item.setText(getResourceString("tool.New.folder.text"));

    item.setToolTipText(getResourceString("tool.New.folder.tip"));

   

    item.addSelectionListener(new SelectionAdapter () {

      public void widgetSelected(SelectionEvent e)

      {

        VFSUtil.newFolder(getCurrentDirectory());

      }

    });

   

    item = new ToolItem(toolBar, SWT.SEPARATOR);

   

    // Parent

    item = new ToolItem(toolBar, SWT.PUSH);

    item.setImage(iconCache.get(CFPluginImages.ICON_FOLDER_PARENT));

    //item.setText(getResourceString("tool.Parent.tiptext"));

    item.setToolTipText(getResourceString("tool.Parent.tiptext"));

    item.addSelectionListener(new SelectionAdapter () {

      public void widgetSelected(SelectionEvent e) {

        doParent();

      }

    });

   

    // Refresh

    item = new ToolItem(toolBar, SWT.PUSH);

    item.setImage(iconCache.get(CFPluginImages.ICON_REFRESH));

    //item.setText(getResourceString("tool.Refresh.tiptext"));

    item.setToolTipText(getResourceString("tool.Refresh.tiptext"));

    item.addSelectionListener(new SelectionAdapter () {

      public void widgetSelected(SelectionEvent e) {

        doRefresh();

      }

    });

 

    return toolBar;

  }

  /**

   * Creates the combo box view.

   *

   * @param parent the parent control

   */

  private Control createComboView(Composite parent, Object layoutData)

  {

    combo = new Combo(parent, SWT.NONE);

    combo.setLayoutData(layoutData);

    combo.addSelectionListener(new SelectionAdapter() {

     

      public void widgetSelected(SelectionEvent e)

      {

        final FileObject[] roots = (FileObject[]) combo.getData(COMBODATA_ROOTS);

        if (roots == null) return;

        int selection = combo.getSelectionIndex();

       

        if (selection >= 0 && selection < roots.length)

        {

          try {

            System.out.println("combo.widgetSelected " + roots[selection]);

            notifySelectedDirectory(roots[selection],roots[selection].getName().toString());

          } catch (Exception ex) {

            System.err.println("createComboView.widgetSelected: " + ex);

          }

        }

      }

     

      public void widgetDefaultSelected(SelectionEvent e) {

        final String lastText = (String) combo.getData(COMBODATA_LASTTEXT);

        final String lastConnectionId = (String) combo.getData(COMBODATA_LASTCONNECTIONID);

        String text = combo.getText();

        if (text == null) return;

        if (lastText != null && lastText.equals(text)) return;

        combo.setData(COMBODATA_LASTTEXT, text);

       

        try {

          FileObject file = resolveURI(text,lastConnectionId);

         

          if ( file.exists() )

            notifySelectedDirectory(file,lastConnectionId);

          else {

            VFSUtil.MessageBoxInfo(

                getResourceString("file.not.found", new Object[] {file}) );

            combo.setText(getCurrentDirectory().toString());

          }

         

        } catch (FileSystemException ex) {

          System.err.println("createComboView::widgetDefaultSelected Error: " + ex);

        }

      }

    });

    return combo;

  }

  /**

   * Creates the file tree view.

   *

   * @param parent the parent control

   */

  private void createTreeView(Composite parent) {

    Composite composite = new Composite(parent, SWT.NONE);

    GridLayout gridLayout = new GridLayout();

    gridLayout.numColumns = 1;

    gridLayout.marginHeight = gridLayout.marginWidth = 2;

    gridLayout.horizontalSpacing = gridLayout.verticalSpacing = 0;

    composite.setLayout(gridLayout);

    treeScopeLabel = new Label(composite, SWT.BORDER);

    treeScopeLabel.setText(VFSView.getResourceString("details.AllFolders.text"));

    treeScopeLabel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_FILL));

    tree = new Tree(composite, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE);

    tree.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL));

    tree.addSelectionListener(new SelectionListener() {

      public void widgetSelected(SelectionEvent event)

      {

       

        final TreeItem[] selection = tree.getSelection();

        if (selection != null && selection.length != 0) {

          TreeItem item = selection[0];

         

          try {

            //FileObject file = (FileObject) item.getData(TREEITEMDATA_FILE);

            String uri = (String) item.getData(TREEITEMDATA_URI);

            String connectionId = (String) item.getData(TREEITEMDATA_CONNECTIONID);

           

            shell.setText(getResourceString("Title.Resolving"

                , new Object[] { uri } ));

            notifySelectedDirectory(resolveURI(uri, connectionId),connectionId);

          }

          catch (FileSystemException e) {

            debug(e); // "createTreeView.widgetSelected " +

           

            VFSUtil.MessageBoxError( VFSUtil.getErrorMessageStack(e));

            VFSUtil.setUiStateIdle(shell, getCurrentDirectory().getName().toString());

          }

        }

      }

     

      public void widgetDefaultSelected(SelectionEvent event) {

        final TreeItem[] selection = tree.getSelection();

        if (selection != null && selection.length != 0) {

          TreeItem item = selection[0];

          String imageName;

          if(item.getExpanded()) {

            imageName = TREEITEMDATA_IMAGECOLLAPSED;           

          } else {

            imageName = TREEITEMDATA_IMAGEEXPANDED;

          }

          item.setExpanded(!item.getExpanded());

          final Image image = (Image) item.getData(imageName);

          if (image != null) item.setImage(image);

          treeExpandItem(item);

        }

      }

    });

    tree.addTreeListener(new TreeAdapter() {

      public void treeExpanded(TreeEvent event) {

        final TreeItem item = (TreeItem) event.item;

        final Image image = (Image) item.getData(TREEITEMDATA_IMAGEEXPANDED);

        if (image != null) item.setImage(image);

        treeExpandItem(item);

      }

      public void treeCollapsed(TreeEvent event) {

        final TreeItem item = (TreeItem) event.item;

        final Image image = (Image) item.getData(TREEITEMDATA_IMAGECOLLAPSED);

        if (image != null) item.setImage(image);

      }

    });

   

    // Listen for key presses

    tree.addKeyListener(new KeyAdapter() {

      public void keyPressed(KeyEvent event)

      {

        if ( event.keyCode == 127 )

        {

          TreeItem item = tree.getSelection()[0];

          String connectionId = (String)item.getData(TREEITEMDATA_CONNECTIONID);

         

          // delete at the root level only

          if ( ! (item.getParentItem() == null) ) return;

         

          if ( connectionId.startsWith("file://"))

            VFSUtil.MessageBoxInfo(getResourceString("remove.local.fs"));

          else {

              deleteAction.run(item);

          }

        }

      }

    });

   

    createTreeDragSource(tree);

    createTreeDropTarget(tree);

  }

  /**

   * Creates the Drag & Drop DragSource for items being dragged from the tree.

   *

   * @return the DragSource for the tree

   */

  private DragSource createTreeDragSource(final Tree tree){

    DragSource dragSource = new DragSource(tree, DND.DROP_COPY); // | DND.DROP_MOVE

   

    // Transfer data type is text (file URI)

    dragSource.setTransfer(new Transfer[] { FileTransfer.getInstance() });

    //dragSource.setTransfer(new Transfer[] { RTFTransfer.getInstance() });

   

    dragSource.addDragListener(new DragSourceListener() {

      TreeItem[] dndSelection = null;

      String[] sourceNames = null;

     

      public void dragStart(DragSourceEvent event){

        dndSelection = tree.getSelection();

        sourceNames = null;

        event.doit = dndSelection.length > 0;

        isDragging = true;

      }

     

      public void dragFinished(DragSourceEvent event){

        dragSourceHandleDragFinished(event, sourceNames);

        dndSelection = null;

        sourceNames = null;

        isDragging = false;

//TODO        try {

//          handleDeferredRefresh();

//        } catch (Exception e) {

//          debug ("createTreeDragSource.dragFinished " + e);

//        }

      }

     

      public void dragSetData(DragSourceEvent event){

        if (dndSelection == null || dndSelection.length == 0) return;

        //if (! FileTransfer.getInstance().isSupportedType(event.dataType)) return;

       

        if (! FileTransfer.getInstance().isSupportedType(event.dataType)) {

          //debug("createTreeDragSource.dragSetData File transfer data type is required");

          return;

        }

       

        sourceNames    = new String[dndSelection.length];

        FileObject file = null;

        String uri    = null;

        String connectionId = null;

        for (int i = 0; i < dndSelection.length; i++) {

          uri   = (String) dndSelection[i].getData(TREEITEMDATA_URI);

          connectionId = (String) dndSelection[i].getData(TREEITEMDATA_CONNECTIONID);

          try {

            file   = resolveURI(uri,connectionId);

          } catch (FileSystemException e) {

            debug(e); //"createTreeDragSource.dragSetData " +

            continue;

          }

         

          /*

           * In Order for FileTransfer to Work, the name must begin w/

           * / in UNIX systems

           */

          sourceNames[i] = Os.isFamily(Os.OS_FAMILY_UNIX)

            ? FileName.SEPARATOR + file.toString()

            : file.toString();

     

          System.out.println("createTreeDragSource.dragSetData file path=" + sourceNames[i]);         

        }

        //sourceNames[0] = connectionId;

        fSourceConnectionId = connectionId;

        event.data = sourceNames;

      }

    });

    return dragSource;

  }

  /**

   * Creates the Drag & Drop DropTarget for items being dropped onto the tree.

   *

   * @return the DropTarget for the tree

   */

  private DropTarget createTreeDropTarget(final Tree tree)

  {

    DropTarget dropTarget = new DropTarget(tree, DND.DROP_COPY); // | DND.DROP_MOVE

   

    dropTarget.setTransfer(new Transfer[] { FileTransfer.getInstance() });

   

    // Transfer data type is text

    //dropTarget.setTransfer(new Transfer[] { RTFTransfer.getInstance()} );

   

    dropTarget.addDropListener(new DropTargetAdapter() {

      public void dragEnter(DropTargetEvent event) {

        isDropping = true;

      }

      public void dragLeave(DropTargetEvent event) {

        isDropping = false;

//          handleDeferredRefresh();

//        } catch (Exception e) {

//          debug("createTreeDropTarget.dragLeave " + e);

//        }

      }

      public void dragOver(DropTargetEvent event) {

        dropTargetValidate(event, getTargetFile(event));

        event.feedback |= DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;

      }

     

      public void drop(DropTargetEvent event) {

        FileAndConnectionId targetFile = getTargetFile(event);

       

        try {

          if (dropTargetValidate(event, targetFile))

            dropTargetHandleDrop(event, targetFile);

         

        }

        catch (FileSystemException e) {

          VFSUtil.MessageBoxError(e.getMessage());

        }

        catch (Exception e1) {

          debug(e1); // "createTreeDropTarget.drop " +

        }

      }

     

      private FileAndConnectionId getTargetFile(DropTargetEvent event) {

        // Determine the target FileObject for the drop

        TreeItem item = tree.getItem(tree.toControl(new Point(event.x, event.y)));

        FileObject targetFile = null;

        String connectionId = "";

       

        if (item != null) {

          // We are over a particular item in the tree, use the item's file

          //targetFile = (FileObject) item.getData(TREEITEMDATA_FILE);

          String uri = (String)item.getData(TREEITEMDATA_URI);

          connectionId = (String)item.getData(TREEITEMDATA_CONNECTIONID);

          try {

            targetFile   = resolveURI(uri,connectionId);

          } catch (Exception e) {

            debug(e); //"createTreeDropTarget.getTargetFile " +

          }

        }

        return new FileAndConnectionId(targetFile,connectionId);

      }

    });

    return dropTarget; 

  }

  /**

   * Handles expand events on a tree item.

   *

   * @param item the TreeItem to fill in

   */

  private void treeExpandItem(TreeItem item) 

  {

    shell.setCursor(CFPluginImages.cursors[CFPluginImages.cursorWait]);

    final Object stub = item.getData(TREEITEMDATA_STUB);

   

    if (stub == null) {

      try {

        treeRefreshItem(item, true);

      } catch (Exception e) {

        debug(e); // "treeExpandItem " +

      }

    }

    shell.setCursor(CFPluginImages.cursors[CFPluginImages.cursorDefault]);

  }

 

  /**

   * Add a file sytem node

   * @param filesystem

   */

  public void addFileSystem (String connectionId)

  {

    try {     

      TreeItem newItem = new TreeItem(tree, SWT.NULL);

      treeInitVolume(newItem, connectionId) ;// masterFile);

     

      //  placeholder child item to get "expand" button

      new TreeItem(newItem, SWT.NULL);

     

    } catch (Exception e) {

      VFSUtil.MessageBoxInfo(e.getMessage());

    }

  }

 

  /**

   * Traverse the entire tree and update only what has changed.

   *

   * @param roots the root directory listing

   */

  private void treeRefresh(FileObject[] masterFiles) {

    TreeItem[] items = tree.getItems();

    int masterIndex = 0;

    int itemIndex = 0;

    for (int i = 0; i < items.length; ++i) {

      final TreeItem item = items[i];

      final FileObject itemFile = null;

     

     

      if ((itemFile == null) || (masterIndex == masterFiles.length)) {

        // remove bad item or placeholder

        item.dispose();

        continue;

      }

      final FileObject masterFile = masterFiles[masterIndex];

     

      int compare = VFSUtil.compareFiles(masterFile, itemFile);

     

      if (compare == 0) {

        // same file, update it

        try {

          treeRefreshItem(item, false);

        } catch (Exception e) {

          error("treeRefresh.treeRefreshItem " + e);

        }

       

        ++itemIndex;

        ++masterIndex;