com.ikon.frontend.client.widget.foldertree.FolderTree.java Source code

Java tutorial

Introduction

Here is the source code for com.ikon.frontend.client.widget.foldertree.FolderTree.java

Source

/**
 *  openkm, Open Document Management System (http://www.openkm.com)
 *  Copyright (c) 2006-2013  Paco Avila & Josep Llort
 *
 *  No bytes were intentionally harmed during the development of this application.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package com.ikon.frontend.client.widget.foldertree;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.google.gwt.core.client.GWT;
import com.google.gwt.event.logical.shared.CloseEvent;
import com.google.gwt.event.logical.shared.CloseHandler;
import com.google.gwt.event.logical.shared.OpenEvent;
import com.google.gwt.event.logical.shared.OpenHandler;
import com.google.gwt.event.logical.shared.SelectionEvent;
import com.google.gwt.event.logical.shared.SelectionHandler;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.TreeItem;
import com.ikon.frontend.client.Main;
import com.ikon.frontend.client.OKMException;
import com.ikon.frontend.client.bean.GWTFolder;
import com.ikon.frontend.client.bean.GWTPermission;
import com.ikon.frontend.client.constants.service.ErrorCode;
import com.ikon.frontend.client.constants.ui.UIDesktopConstants;
import com.ikon.frontend.client.service.OKMFolderService;
import com.ikon.frontend.client.service.OKMFolderServiceAsync;
import com.ikon.frontend.client.service.OKMNotifyService;
import com.ikon.frontend.client.service.OKMNotifyServiceAsync;
import com.ikon.frontend.client.service.OKMRepositoryService;
import com.ikon.frontend.client.service.OKMRepositoryServiceAsync;
import com.ikon.frontend.client.util.Util;
import com.ikon.frontend.client.widget.ConfirmPopup;
import com.ikon.frontend.client.widget.MenuPopup;
import com.ikon.frontend.client.widget.OriginPanel;

/**
 * Folder tree
 * 
 * @author jllort
 * 
 */
public class FolderTree extends Composite implements OriginPanel {

    // Definitions of folder actions
    public static final int ACTION_NONE = -1;
    public static final int ACTION_CREATE = 0;
    public static final int ACTION_RENAME = 1;
    public static final int ACTION_SECURITY_REFRESH = 2;

    private final OKMFolderServiceAsync folderService = (OKMFolderServiceAsync) GWT.create(OKMFolderService.class);
    private final OKMNotifyServiceAsync notifyService = (OKMNotifyServiceAsync) GWT.create(OKMNotifyService.class);
    private final OKMRepositoryServiceAsync repositoryService = (OKMRepositoryServiceAsync) GWT
            .create(OKMRepositoryService.class);

    private ExtendedTree tree;
    public TreeItem actualItem;
    public FolderSelectPopup folderSelectPopup;
    public FolderSelectPopup folderSelectPopup1;
    public MenuPopup menuPopup;
    private boolean panelSelected = true; // Indicates if panel is selected

    public TreeItem tmpFolder; // Used temporary to create new folder
    private FolderTextBox renFolder; // Used temporary to rename a new folder
    public GWTFolder folderRoot; // To preserve folder root value
    public TreeItem rootItem;
    ArrayList<String> tmpAllPathFolder = new ArrayList<String>(); // Store node path elements
    public int folderAction = ACTION_NONE; // To control rename and create

    // folder actions
    private TreeItem otherTreeItemSelected = null;
    private String tmpRenameHtmlFolder;
    private boolean refreshFileBrowser = false;
    private boolean setTabFolderAfterRefresh = false;
    private boolean treeItemChanged = false;
    private boolean treeItemHasBeenClosed = false;
    private boolean autoOpenFolder = false;
    private boolean openingFldPath = false;
    private boolean flagFileBrowserFinished = true;

    /**
     * Directory Tree
     */
    public FolderTree() {
        tree = new ExtendedTree();
        tmpFolder = new TreeItem("");
        tmpFolder.setStyleName("okm-TreeItem");
        folderSelectPopup = new FolderSelectPopup();
        folderSelectPopup1 = new FolderSelectPopup(true);
        folderSelectPopup.setWidth("450");
        folderSelectPopup.setHeight("440");
        folderSelectPopup.setStyleName("okm-Popup");
        TreeItem rootItem = new TreeItem(Util.imageItemHTML("img/menuitem_childs.gif", "root_schema", "top"));
        rootItem.setStyleName("okm-TreeItem");
        rootItem.setUserObject(new GWTFolder());
        rootItem.setSelected(true);
        rootItem.setState(true);
        rootItem.addStyleName("okm-DisableSelect"); // Disables drag and drop
        // browser text selection
        tree.setStyleName("okm-Tree");
        tree.addStyleName("okm-PanelSelected");
        tree.addItem(rootItem);

        tree.addSelectionHandler(new SelectionHandler<TreeItem>() {
            @Override
            public void onSelection(SelectionEvent<TreeItem> event) {
                if (!openingFldPath && flagFileBrowserFinished) {
                    final TreeItem treeItem = event.getSelectedItem();
                    Timer openIfNotClosed = new Timer() {
                        @Override
                        public void run() {
                            if (!treeItemHasBeenClosed) {
                                onTreeItemSelected(treeItem);
                                // Case is closed parent which selected forder is the child
                            } else if (treeItemHasBeenClosed && !actualItem.equals(treeItem)
                                    && ((GWTFolder) actualItem.getUserObject()).getPath()
                                            .contains(((GWTFolder) treeItem.getUserObject()).getPath())) {
                                actualItem.setSelected(false);
                                treeItem.setSelected(true);
                                onTreeItemSelected(treeItem);
                            } else {
                                treeItemHasBeenClosed = false;
                            }
                        }
                    };
                    if (treeItem != null) {
                        openIfNotClosed.schedule(50);
                    }
                }
            }
        });

        tree.addCloseHandler(new CloseHandler<TreeItem>() {
            @Override
            public void onClose(CloseEvent<TreeItem> event) {
                Main.get().dragable.clear();
                treeItemHasBeenClosed = true;
            }
        });
        tree.addOpenHandler(new OpenHandler<TreeItem>() {
            @Override
            public void onOpen(OpenEvent<TreeItem> event) {
                if (flagFileBrowserFinished) {
                    TreeItem treeItem = event.getTarget();
                    if (!openingFldPath && !autoOpenFolder) {
                        if (!actualItem.equals(treeItem)) {
                            actualItem.setSelected(false);
                            treeItem.setSelected(true);
                        }
                        onTreeItemSelected(event.getTarget());
                    } else {
                        autoOpenFolder = false; // always reset value
                    }
                }
            }
        });
        actualItem = tree.getItem(0);
        initWidget(tree);
    }

    /**
     * Inits on first load
     */
    public void init() {
    }

    /**
     * Refresh language values
     */
    public void langRefresh() {
        menuPopup.langRefresh();
        folderSelectPopup.langRefresh();
        //folderSelectPopup1.langRefresh();
    }

    /**
     * Refresh asyncronous subtree branch
     */
    final AsyncCallback<List<GWTFolder>> callbackGetChilds = new AsyncCallback<List<GWTFolder>>() {
        public void onSuccess(List<GWTFolder> result) {
            List<GWTFolder> folderList = result;

            autoOpenFolder = actualItem.getState(); // Actual folder open state
            // Case first refreshing when (childcount = 0 or treeItem changed ) and results >0 must ensure enables auto open
            if ((actualItem.getChildCount() == 0 || treeItemChanged) && result.size() > 0) {
                autoOpenFolder = true;
            }

            // Remove all items
            if (actualItem.getChildCount() > 0) {
                actualItem.removeItems();
            }

            // On refreshing not refreshed the actual item values but must
            // ensure that has childs value is consistent
            if (folderList.isEmpty()) {
                ((GWTFolder) actualItem.getUserObject()).setHasChildren(false);
            } else {
                ((GWTFolder) actualItem.getUserObject()).setHasChildren(true);
            }

            // Ads folders childs if exists
            for (Iterator<GWTFolder> it = folderList.iterator(); it.hasNext();) {
                GWTFolder folder = it.next();
                TreeItem folderItem = new TreeItem(folder.getName());
                folderItem.setUserObject(folder);
                folderItem.setStyleName("okm-TreeItem");

                // add values 
                evaluesFolderIcon(folderItem);
                actualItem.addItem(folderItem);
            }
            // Evaluates special case has closed parent folder ( and selected folder was a child )
            if (!treeItemHasBeenClosed) {
                actualItem.setState(autoOpenFolder); // Enables auto open or close tree node
            } else {
                treeItemHasBeenClosed = false;
            }
            evaluesFolderIcon(actualItem);

            if (setTabFolderAfterRefresh) {
                // Refresh tab properties values on the last node
                showTabFolderProperties();
                setTabFolderAfterRefresh = false;
            }

            Main.get().mainPanel.desktop.navigator.status.unsetFlagChilds();
        }

        public void onFailure(Throwable caught) {
            Main.get().mainPanel.desktop.navigator.status.unsetFlagChilds();
            Main.get().showError("GetChilds", caught);
        }
    };

    /**
     * Refresh asyncronous subtree branch
     */
    final AsyncCallback<List<GWTFolder>> callbackGetOnlyChilds = new AsyncCallback<List<GWTFolder>>() {
        public void onSuccess(List<GWTFolder> result) {
            List<GWTFolder> folderList = result;

            // Remove olders items
            if (actualItem.getChildCount() > 0) {
                actualItem.removeItems();
            }

            // On refreshing not refreshed the actual item values but must
            // ensure that has childs value is consistent
            if (folderList.isEmpty()) {
                ((GWTFolder) actualItem.getUserObject()).setHasChildren(false);
            } else {
                ((GWTFolder) actualItem.getUserObject()).setHasChildren(true);
            }

            // Ads folders childs if exists
            for (Iterator<GWTFolder> it = folderList.iterator(); it.hasNext();) {
                GWTFolder folder = it.next();
                TreeItem folderItem = new TreeItem(folder.getName());
                folderItem.setUserObject(folder);
                folderItem.setStyleName("okm-TreeItem");

                // add values 
                evaluesFolderIcon(folderItem);
                actualItem.addItem(folderItem);
            }

            actualItem.setState(true);
            evaluesFolderIcon(actualItem);

            if (!tmpAllPathFolder.isEmpty()) {
                int index = tmpAllPathFolder.size() - 1;
                String tmpPath = tmpAllPathFolder.get(index);
                tmpAllPathFolder.remove(index);
                if (index > 0) {
                    setActiveNode(tmpPath, false, false);
                } else {
                    setActiveNode(tmpPath, false, refreshFileBrowser);
                }
            } else {
                openingFldPath = false;
            }
        }

        public void onFailure(Throwable caught) {
            Main.get().showError("GetOnlyChilds", caught);
        }
    };

    /**
     * Refresh asyncronous subtree branch after an item menu is deleted
     */
    final AsyncCallback<Object> callbackDelete = new AsyncCallback<Object>() {
        public void onSuccess(Object result) {
            TreeItem tmpItem = actualItem;
            actualItem = actualItem.getParentItem();
            actualItem.setSelected(true);
            actualItem.setState(true);
            actualItem.removeItem(tmpItem);
            evaluesFolderIcon(actualItem);
            showTabFolderProperties();
            Main.get().mainPanel.desktop.navigator.status.unsetFlagDelete();
            refresh(true);
        }

        public void onFailure(Throwable caught) {
            Main.get().mainPanel.desktop.navigator.status.unsetFlagDelete();
            Main.get().showError("Delete", caught);
        }
    };

    /**
     * Gets actual folder node
     */
    final AsyncCallback<GWTFolder> callbackGet = new AsyncCallback<GWTFolder>() {
        public void onSuccess(GWTFolder result) {
            actualItem.setUserObject(result);
            evaluesFolderIcon(actualItem);

            if (folderAction == ACTION_SECURITY_REFRESH) {
                Main.get().mainPanel.desktop.browser.tabMultiple.tabFolder
                        .setProperties((GWTFolder) actualItem.getUserObject());
                folderAction = ACTION_NONE;
            }

            Main.get().mainPanel.desktop.navigator.status.unsetFlagGet();
        }

        public void onFailure(Throwable caught) {
            folderAction = ACTION_NONE; // Ensures on error folder action be
            // restores
            Main.get().mainPanel.desktop.navigator.status.unsetFlagGet();
            Main.get().showError("GetFolder", caught);
        }
    };

    /**
     * Call back create
     */
    final AsyncCallback<GWTFolder> callbackCreate = new AsyncCallback<GWTFolder>() {
        public void onSuccess(GWTFolder result) {
            actualItem = actualItem.getParentItem(); // Restores the real
            // actualItem
            tmpFolder.setSelected(false);
            actualItem.setSelected(true);
            actualItem.setState(true);
            GWTFolder folder = result;
            GWTFolder folderItem = (GWTFolder) actualItem.getUserObject();
            folderItem.setHasChildren(true);
            actualItem.removeItem(tmpFolder);
            TreeItem newFolder = new TreeItem(
                    Util.imageItemHTML("img/menuitem_empty.gif", folder.getName(), "top"));
            newFolder.setUserObject(folder);
            newFolder.setStyleName("okm-TreeItem");
            actualItem.addItem(newFolder);
            evaluesFolderIcon(newFolder);
            evaluesFolderIcon(actualItem);
            Main.get().mainPanel.desktop.navigator.status.unsetFlagCreate();
            if (Main.get().mainPanel.desktop.navigator.getStackIndex() != UIDesktopConstants.NAVIGATOR_CATEGORIES) {
                Main.get().mainPanel.desktop.browser.fileBrowser.status.setFlagFolderChilds();
                Main.get().mainPanel.desktop.browser.fileBrowser.addFolder(folder);
            }

            // Special case when we are creating a folder and selects other tree
            // item before removing tmp folder
            // must changing to the real item selected
            if (otherTreeItemSelected != null) {
                onTreeItemSelected(otherTreeItemSelected);
                otherTreeItemSelected = null;
            }

            folderAction = ACTION_NONE;
        }

        public void onFailure(Throwable caught) {
            // On error remove tmp folder
            removeTmpFolderCreate();
            folderAction = ACTION_NONE;
            Main.get().mainPanel.desktop.navigator.status.unsetFlagCreate();
            Main.get().showError("Create", caught);
        }
    };

    /**
     * Call back rename
     */
    final AsyncCallback<GWTFolder> callbackRename = new AsyncCallback<GWTFolder>() {
        public void onSuccess(GWTFolder result) {
            GWTFolder folder = result;
            String oldPath = ((GWTFolder) actualItem.getUserObject()).getPath();
            actualItem.setUserObject(folder);
            evaluesFolderIcon(actualItem);
            showTabFolderProperties();
            String path = ((GWTFolder) actualItem.getUserObject()).getPath();
            Main.get().mainPanel.desktop.browser.fileBrowser.refresh(path);
            Main.get().mainPanel.desktop.navigator.status.unsetFlagRename();
            path = path.substring(1); // deletes first character "/" because
            // parent path not has
            oldPath = oldPath.substring(1); // deletes first character "/"
            // because parent path not has
            changePathBeforeRenaming(oldPath, path, actualItem);
            folderAction = ACTION_NONE;
        }

        public void onFailure(Throwable caught) {
            folderAction = ACTION_NONE;
            Main.get().mainPanel.desktop.navigator.status.unsetFlagRename();
            Main.get().showError("Rename", caught);
            cancelRename(); // Cancel renaming on error
        }
    };

    /**
     * Callback add subscription
     */
    final AsyncCallback<Object> callbackAddSubscription = new AsyncCallback<Object>() {
        public void onSuccess(Object result) {
            ((GWTFolder) actualItem.getUserObject()).setSubscribed(true);
            ((GWTFolder) actualItem.getUserObject()).getSubscriptors()
                    .add(Main.get().workspaceUserProperties.getUser()); // Adds user
            // on
            // subscribed
            // list

            GWTFolder folderParent;

            // Case actualItem is root then folder parent is actualItem folder
            if (actualItem == rootItem) {
                folderParent = (GWTFolder) actualItem.getUserObject();
            } else {
                folderParent = (GWTFolder) actualItem.getParentItem().getUserObject();
            }
            Main.get().mainPanel.topPanel.toolBar.checkToolButtonPermissions((GWTFolder) actualItem.getUserObject(),
                    folderParent, TREE_ROOT);
            evaluesFolderIcon(actualItem);
            Main.get().mainPanel.desktop.navigator.status.unsetFlagAddSubscription();
            showTabFolderProperties(); // Refresh folder properties
            Main.get().mainPanel.dashboard.userDashboard.getUserSubscribedFolders();
        }

        public void onFailure(Throwable caught) {
            Main.get().mainPanel.desktop.navigator.status.unsetFlagAddSubscription();
            Main.get().showError("AddSubscription", caught);
        }
    };

    /**
     * Callback remove subscription
     */
    final AsyncCallback<Object> callbackRemoveSubscription = new AsyncCallback<Object>() {
        public void onSuccess(Object result) {
            ((GWTFolder) actualItem.getUserObject()).setSubscribed(false);
            ((GWTFolder) actualItem.getUserObject()).getSubscriptors()
                    .remove(Main.get().workspaceUserProperties.getUser()); // Remove
            // user from
            // subscription
            // list
            GWTFolder folderParent;

            // Case actualItem is root then folder parent is actualItem folder
            if (actualItem == rootItem) {
                folderParent = (GWTFolder) actualItem.getUserObject();
            } else {
                folderParent = (GWTFolder) actualItem.getParentItem().getUserObject();
            }
            Main.get().mainPanel.topPanel.toolBar.checkToolButtonPermissions((GWTFolder) actualItem.getUserObject(),
                    folderParent, TREE_ROOT);
            evaluesFolderIcon(actualItem);
            Main.get().mainPanel.desktop.navigator.status.unsetFlagRemoveSubscription();
            showTabFolderProperties(); // Refresh folder properties
            Main.get().mainPanel.dashboard.userDashboard.getUserSubscribedFolders();
        }

        public void onFailure(Throwable caught) {
            Main.get().mainPanel.desktop.navigator.status.unsetFlagRemoveSubscription();
            Main.get().showError("AddSubscription", caught);
        }
    };

    /**
     * Refresh the folders on a item node
     * 
     * @param path
     *            The folder path selected to list items
     */
    public void getChilds(String path) {
        folderService.getChilds(path, false, callbackGetChilds);
        Main.get().mainPanel.desktop.navigator.status.setFlagChilds();
    }

    /**
     * Refresh the folders on a item node Used on firstTime loading for
     * personal, trash and templates. Only loads tree folders not refresh
     * filebrowser
     * 
     * @param path
     *            The folder path selected to list items
     */
    public void getOnlyChilds(String path) {
        folderService.getChilds(path, false, callbackGetOnlyChilds);
    }

    /**
     * Creates a new folder on actual item
     * 
     * @param path
     *            The folder subpath selected by user = name
     */
    public void create(String path) {
        // On creation the actualItem is tmpFolder and must create from the
        // parent of tmpFolder ( the real actualItem )
        folderService.create(path, ((GWTFolder) actualItem.getParentItem().getUserObject()).getPath(),
                callbackCreate);
        Main.get().mainPanel.desktop.navigator.status.setFlagCreate();
        hideMenuPopup();
    }

    /**
     * Rename a folder on actual item
     * 
     * @param path
     *            The folder subpath selected by user = name
     */
    public void rename(String path) {
        folderService.rename(((GWTFolder) actualItem.getUserObject()).getPath(), path, callbackRename);
        Main.get().mainPanel.desktop.navigator.status.setFlagRename();
        hideMenuPopup();
    }

    /**
     * Show a previos message to confirm delete
     */
    public void confirmDelete() {
        // In categories stack view, must not fire deleting if user view some
        // document
        if (!(Main.get().mainPanel.desktop.navigator.getStackIndex() == UIDesktopConstants.NAVIGATOR_CATEGORIES
                && Main.get().mainPanel.desktop.browser.fileBrowser.hasRows())) {
            Main.get().confirmPopup.setConfirm(ConfirmPopup.CONFIRM_DELETE_FOLDER);
            Main.get().confirmPopup.show();
        } else {
            String msg = Main.i18n("categories.folder.error.delete");
            OKMException exception = new OKMException(
                    ErrorCode.get(ErrorCode.ORIGIN_OKMFolderService, ErrorCode.CAUSE_AccessDenied), msg);
            Main.get().showError("delete", exception);
        }
    }

    /**
     * Deletes a folder, the folder deleted is the actual item and refresh the
     * parent
     */
    public void delete() {
        String path = ((GWTFolder) actualItem.getUserObject()).getPath();
        folderService.delete(path, callbackDelete);
        Main.get().mainPanel.desktop.navigator.status.setFlagDelete();
        hideMenuPopup();
    }

    /**
     * Deletes folder on trash after is moved
     */
    public void deleteMovedOrRestored() {
        TreeItem tmpItem = actualItem;
        actualItem = actualItem.getParentItem();
        actualItem.setSelected(true);
        actualItem.setState(true);
        actualItem.removeItem(tmpItem);
        evaluesFolderIcon(actualItem);
        showTabFolderProperties();
        refresh(true);
    }

    /**
     * Move folder on file browser ( only trash mode )
     */
    public void move() {
        GWTFolder folderToRestore = (GWTFolder) actualItem.getUserObject();
        folderSelectPopup.setEntryPoint(FolderSelectPopup.ENTRYPOINT_TAXONOMY);
        folderSelectPopup.setToMove(folderToRestore);
        showDirectorySelectPopup();
    }

    /**
     * Copy folder on file browser ( only trash mode )
     */
    public void copy() {
        GWTFolder folderToCopy = (GWTFolder) actualItem.getUserObject();
        folderSelectPopup.setEntryPoint(FolderSelectPopup.ENTRYPOINT_TAXONOMY);
        folderSelectPopup.setToCopy(folderToCopy);
        showDirectorySelectPopup();
    }

    /**
     * massiveCopy
     */
    public void massiveCopy() {
        GWTFolder parentFolder = (GWTFolder) actualItem.getUserObject();
        folderSelectPopup.setEntryPoint(FolderSelectPopup.ENTRYPOINT_TAXONOMY);
        folderSelectPopup.setToMassiveCopy(parentFolder);
        showDirectorySelectPopup();
    }

    /**
     * massiveMove
     */
    public void massiveMove() {
        GWTFolder parentFolder = (GWTFolder) actualItem.getUserObject();
        folderSelectPopup.setEntryPoint(FolderSelectPopup.ENTRYPOINT_TAXONOMY);
        folderSelectPopup.setToMassiveMove(parentFolder);
        showDirectorySelectPopup();
    }

    /**
     * massiveRestore
     */
    public void massiveRestore() {
        GWTFolder parentFolder = (GWTFolder) actualItem.getUserObject();
        folderSelectPopup.setEntryPoint(FolderSelectPopup.ENTRYPOINT_TAXONOMY);
        folderSelectPopup.setToMassiveRestore(parentFolder);
        showDirectorySelectPopup();
    }

    /**
     * Remove folder from tree after deleted from repository ( normaly deleted
     * on file browser )
     * 
     * @param path
     *            The folder
     */
    public void removeDeleted(String path) {
        boolean found = false;
        int i = 0;

        while (!found && actualItem.getChildCount() > i) {
            TreeItem tmp = actualItem.getChild(i);

            if (((GWTFolder) tmp.getUserObject()).getPath().equals(path)) {
                actualItem.removeItem(tmp);
                found = true;
            }
            i++;
        }

        // Looks if must change icon on parent if now has no childs and
        // properties
        if (actualItem.getChildCount() < 1) {
            GWTFolder folderItem = (GWTFolder) actualItem.getUserObject();
            folderItem.setHasChildren(false);
        }

        evaluesFolderIcon(actualItem);
    }

    /**
     * Adds a subscription
     */
    public void addSubscription() {
        Main.get().mainPanel.desktop.navigator.status.setFlagAddSubscription();
        notifyService.subscribe(((GWTFolder) actualItem.getUserObject()).getPath(), callbackAddSubscription);
    }

    /**
     * Removes a subscription
     */
    public void removeSubscription() {
        Main.get().mainPanel.desktop.navigator.status.setFlagRemoveSubscription();
        notifyService.unsubscribe(((GWTFolder) actualItem.getUserObject()).getPath(), callbackRemoveSubscription);
    }

    /**
     * Get the child folder if folder child path exists on actual tree Item
     * selected
     * 
     * @param path
     *            The path
     * @return
     */
    public TreeItem getChildFolder(String path) {
        boolean found = false;
        int i = 0;
        TreeItem tmp;

        while (!found && actualItem.getChildCount() > i) {
            tmp = actualItem.getChild(i);

            if (((GWTFolder) tmp.getUserObject()).getPath().equals(path)) {
                found = true;
                return tmp;
            }
            i++;
        }

        return null;
    }

    /**
     * Refreshing when folder is renamed remotelly For example on file browser
     * view
     * 
     * @param path
     *            The tree path ( last value )
     * @param newFolder
     *            The new object value
     */
    public void renameRenamed(String path, GWTFolder newFolder) {
        boolean found = false;
        int i = 0;

        while (!found && actualItem.getChildCount() > i) {
            TreeItem tmp = actualItem.getChild(i);

            if (((GWTFolder) tmp.getUserObject()).getPath().equals(path)) {
                tmp.setUserObject(newFolder);
                // Evalues Folder Icon puts name and icon correct values from
                // object
                evaluesFolderIcon(tmp);
                found = true;
                String oldPath = path.substring(1); // deletes first character
                // "/" because parent path
                // not has and replace not
                // runs properly
                path = newFolder.getPath().substring(1); // deletes first
                // character "/"
                // because parent
                // path not has and
                // replace not runs
                // properly
                changePathBeforeRenaming(oldPath, path, tmp);
            }

            i++;
        }
    }

    /**
     * Gets the actual folder (actualItem) and refresh all information on it
     */
    private void get() {
        Main.get().mainPanel.desktop.navigator.status.setFlagGet();
        folderService.getProperties(((GWTFolder) actualItem.getUserObject()).getPath(), callbackGet);
    }

    /**
     * Opens all path since folder path
     * 
     * @param fldId
     *            The folder path
     * @param docPath
     *            The document path
     */
    public void openAllPathFolder(String fldId, String docPath) {
        flagFileBrowserFinished = false;
        openingFldPath = true;
        refreshFileBrowser = true;
        String rootPath = folderRoot.getPath();
        String actualPath = fldId;
        // getChilds method needs it for last
        // folder)

        // Set the selected document to file browser
        // The browser is only called on the last child node refreshing and
        // restores selected row id
        if (refreshFileBrowser && docPath != null && !docPath.equals("")) {
            Main.get().mainPanel.desktop.browser.fileBrowser.cleanAllFilteringValues(); // Ensure the document will be selected
            Main.get().mainPanel.desktop.browser.fileBrowser.setSelectedRowId(docPath);
        } else {
            Main.get().mainPanel.desktop.browser.fileBrowser.setSelectedRowId(""); // We remove the selectedRowID
            if (!rootPath.equals(actualPath)) { // Only if rootPath != actualPath ( case must open folders )
                setTabFolderAfterRefresh = true; // We must set tab folder properties on the last node
            }
        }

        while (actualPath.length() > 0) {
            tmpAllPathFolder.add(actualPath);
            actualPath = actualPath.substring(0, actualPath.lastIndexOf("/"));
        }
        // The last path value is root path, is added on tmpPath

        // Selects root node
        actualItem.setState(true);
        actualItem.setSelected(false);
        actualItem = rootItem;
        actualItem.setSelected(true);

        if (!tmpAllPathFolder.isEmpty()) {
            int index = tmpAllPathFolder.size() - 1;
            String tmpPath = tmpAllPathFolder.get(index);
            tmpAllPathFolder.remove(index);
            if (index > 0) {
                setActiveNode(tmpPath, true, false);
            } else {
                setActiveNode(tmpPath, true, refreshFileBrowser); // Never should go into
            }
        } else {
            openingFldPath = false;
            centerActualItemOnScroll(actualItem); // Centers the actualItem
            // selected if scroll is
            // showed
            if (refreshFileBrowser) {

                // && docPath!=null && !docPath.equals("")
                // Refreshing false and docPath="" special case parameter path
                // pased on browser uri to open
                // panels
                Main.get().mainPanel.desktop.browser.fileBrowser.refresh(rootPath);
            }
        }
    }

    private void onTreeItemSelected(TreeItem item) {
        // Try catch to prevent non controled error which stop foldertree and not send expected filebrowser finish signal to folder tree
        try {
            flagFileBrowserFinished = false;
            treeItemChanged = false;
            boolean refresh = true;
            boolean refreshResetExplorer = true;

            // Always mark panel as selected
            setSelectedPanel(true);

            // Evalutate especial cases rename and creating folder refreshing
            switch (folderAction) {
            case ACTION_CREATE:
                refresh = false;
                if (!actualItem.equals(item)) {
                    // Special case when we are creating a folder and selects other
                    // tree item
                    FolderTextBox folder = (FolderTextBox) tmpFolder.getWidget();
                    // Ensures is text writen before create folder on other case
                    // eliminates
                    if (folder.getText().length() > 0) {
                        otherTreeItemSelected = item; // Used to save item selected
                        create(folder.getText());
                    } else {
                        otherTreeItemSelected = item; // Used to save item selected
                        removeTmpFolderCreate();
                    }
                }
                break;

            case ACTION_RENAME:
                if (actualItem.equals(item)) {
                    refresh = false;
                }
                break;

            default:
                // Case that not refreshing tree and file browser ( right click )
                if (actualItem.equals(item) && tree.isShowPopUP()) {
                    refresh = false; // On right click must not refresh browser but
                    // must change properties view
                    showTabFolderProperties(); // an removes browser selected file
                    // or document if any is selected to
                    // change perspective
                    Main.get().mainPanel.desktop.browser.fileBrowser.deselecSelectedRow();

                } else {
                    // Disables actual item because on changing active node by
                    // application this it's not changed
                    // automatically
                    if (!actualItem.equals(item)) {
                        actualItem.setSelected(false);
                        actualItem = item;
                        refresh = true;
                        treeItemChanged = true;
                        if (tree.isShowPopUP()) {
                            actualItem.setSelected(true);
                        }
                        // refreshType = false;
                    } else {
                        // When the same node is selected must refresh without
                        // mantaining selected filebrowser row
                        refresh = true;
                        refreshResetExplorer = false;
                        showTabFolderProperties(); // On this special case
                        // refreshing tab folder
                        // properties
                        Main.get().mainPanel.desktop.browser.fileBrowser.deselecSelectedRow();
                    }
                }
                // Evaluate privileges
                if (!isActualItemRoot()) {
                    GWTFolder folderParent = (GWTFolder) actualItem.getParentItem().getUserObject();
                    Main.get().mainPanel.topPanel.toolBar.checkToolButtonPermissions(
                            (GWTFolder) actualItem.getUserObject(), folderParent, TREE_ROOT);
                } else {
                    Main.get().mainPanel.topPanel.toolBar.checkToolButtonPermissions(
                            (GWTFolder) actualItem.getUserObject(), folderRoot, TREE_ROOT);
                }

                break;
            }

            if (refresh) {
                refresh(refreshResetExplorer);
            } else {
                flagFileBrowserFinished = true;
            }

            // Only Shows menu popup if flag is enable and selected node is not root
            if (tree.isShowPopUP()) {
                menuPopup.setPopupPosition(tree.mouseX, tree.mouseY);
                // In thesaurus view must not be showed the menu popup
                if (Main.get().mainPanel.desktop.navigator
                        .getStackIndex() != UIDesktopConstants.NAVIGATOR_THESAURUS) {
                    menuPopup.show();
                }
            }
        } catch (Exception e) {
            fileBrowserRefreshDone();
        }
    }

    /**
     * canDrag
     * 
     * @return
     */
    public boolean canDrag() {
        return (folderAction == ACTION_NONE && !actualItem.equals(rootItem)
                && Main.get().mainPanel.desktop.navigator.getStackIndex() != UIDesktopConstants.NAVIGATOR_CATEGORIES
                && Main.get().mainPanel.desktop.navigator.getStackIndex() != UIDesktopConstants.NAVIGATOR_THESAURUS
                && Main.get().mainPanel.desktop.navigator.getStackIndex() != UIDesktopConstants.NAVIGATOR_TRASH);
    }

    /**
     * Refresh the tree node
     */
    public void refresh(final boolean reset) {
        flagFileBrowserFinished = false;
        hideMenuPopup();
        final String path = ((GWTFolder) actualItem.getUserObject()).getPath();
        folderService.getProperties(path, new AsyncCallback<GWTFolder>() {
            @Override
            public void onSuccess(GWTFolder result) {
                // Try catch to prevent non controled error which stop foldertree and not send expected filebrowser finish signal to folder tree
                try {
                    actualItem.setUserObject(result); // Updates folder object with last values
                    evaluesFolderIcon(actualItem); // Ensures to contemplate any security
                    // folder privileges change refresh
                    getChilds(path);

                    // Case not resets always must show tabfolder properties
                    if (!reset) {
                        // Case exists a selected row must mantain other case mus show
                        // folder properties on tab
                        if (Main.get().mainPanel.desktop.browser.fileBrowser.isSelectedRow()) {
                            Main.get().mainPanel.desktop.browser.fileBrowser.mantainSelectedRow();
                        } else {
                            showTabFolderProperties();
                        }
                    } else {
                        showTabFolderProperties();
                    }

                    Main.get().mainPanel.desktop.browser.fileBrowser.refresh(path);
                } catch (Exception e) {
                    fileBrowserRefreshDone();
                }
            }

            @Override
            public void onFailure(Throwable caught) {
                Main.get().showError("getProperties", caught);
                fileBrowserRefreshDone();
            }
        });
    }

    /**
     * Set a new tree node
     * 
     * @param path
     * @param refreshRootNode
     * @param refreshFileBrowser
     */
    public void setActiveNode(String path, boolean refreshRootNode, boolean refreshFileBrowser) {
        // Evaluates first node as special case and then others
        if (actualItem == rootItem && refreshRootNode) {
            if (refreshFileBrowser) {
                getChilds(path);
                Main.get().mainPanel.desktop.browser.fileBrowser.refresh(path);
                refreshFileBrowser = false;
                openingFldPath = false;
                centerActualItemOnScroll(actualItem); // Centers the actualItem selected on scroll
            } else {
                getOnlyChilds(path);
            }
        } else if (actualItem.getChildCount() > 0) {
            int i = 0;
            boolean found = false;
            while (i < actualItem.getChildCount() && !found) {
                if (((GWTFolder) actualItem.getChild(i).getUserObject()).getPath().equals(path)) {
                    found = true;
                    actualItem.setState(true);
                    actualItem.setSelected(false);
                    actualItem = actualItem.getChild(i);
                    actualItem.setSelected(true);
                    if (refreshFileBrowser) {
                        getChilds(path);
                        Main.get().mainPanel.desktop.browser.fileBrowser.refresh(path);
                        refreshFileBrowser = false;
                        openingFldPath = false;
                    } else {
                        getOnlyChilds(path);
                    }
                    centerActualItemOnScroll(actualItem); // Centers the actualItem selected on scroll
                }

                i++;
            }
        } else {
            openingFldPath = false;
        }
        setSelectedPanel(true); // Select this panel
    }

    /**
     * Add temporary folder on creation
     */
    public void addTmpFolderCreate() {
        if (folderAction == ACTION_NONE) {
            folderAction = ACTION_CREATE;
            FolderTextBox newFolder = new FolderTextBox();
            tmpFolder = new TreeItem();
            tmpFolder.setWidget(newFolder);
            tmpFolder.setStyleName("okm-TreeItem");
            newFolder.reset();
            newFolder.setText(Main.i18n("tree.folder.new"));
            actualItem.addItem(tmpFolder);
            actualItem.setState(true);
            actualItem.setSelected(false);
            tmpFolder.setSelected(true);
            actualItem = tmpFolder;
            // When we create a new folder we enables selection ( after it,
            // we'll return to disable) for a normal
            // use of the input (if not, cursor and selections not runs
            // propertly )
            rootItem.removeStyleName("okm-DisableSelect"); // Disables drag and
            // drop browser text
            // selection)
            newFolder.setFocus();
        }
    }

    /**
     * Remove temporary folder on creation Only executed when user closes popup
     * name and
     */
    public void removeTmpFolderCreate() {
        actualItem = tmpFolder.getParentItem();
        tmpFolder.setSelected(false);
        actualItem.setSelected(true);
        actualItem.removeItem(tmpFolder);
        folderAction = ACTION_NONE;

        // Special case when we are creating a folder and selects other tree
        // item before removing tmp folder
        // must changing to the real item selected
        if (otherTreeItemSelected != null) {
            onTreeItemSelected(otherTreeItemSelected);
            otherTreeItemSelected = null;
        }
    }

    /**
     * Gets the actual path of the selected directory tree
     * 
     * @return The actual path of selected directory
     */
    public String getActualPath() {
        return ((GWTFolder) actualItem.getUserObject()).getPath();
    }

    /**
     * Gets the actual tree item of the selected directory tree
     * 
     * @return The actual tree item of selected directory
     */
    public TreeItem getActualItem() {
        return actualItem;
    }

    /**
     * Shows input text to rename selected folder
     */
    public void rename() {
        if (folderAction == ACTION_NONE) {
            Main.get().mainPanel.disableKeyShorcuts(); // Disables key shortcuts
            // while renaming
            folderAction = ACTION_RENAME;
            renFolder = new FolderTextBox();
            renFolder.reset();
            renFolder.setText(actualItem.getText());
            tmpRenameHtmlFolder = actualItem.getHTML();
            actualItem.setWidget(renFolder);
            // When we create a new folder we enables selection ( after it,
            // we'll return to disable) for a normal
            // use of the input (if not, cursor and selections not runs
            // propertly )
            rootItem.removeStyleName("okm-DisableSelect"); // Disables drag and
            // drop browser text
            // selection)
            renFolder.setFocus();
        }
    }

    /**
     * Cancels the renaming folder
     */
    public void cancelRename() {
        actualItem.setHTML(tmpRenameHtmlFolder); // Restores initial icon and name values
        folderAction = ACTION_NONE;
    }

    /**
     * Show Tab Folder Properties
     */
    public void showTabFolderProperties() {
        Main.get().mainPanel.desktop.browser.tabMultiple.enableTabFolder();
        Main.get().mainPanel.desktop.browser.tabMultiple.tabFolder
                .setProperties((GWTFolder) actualItem.getUserObject());
    }

    /**
     * Evalues actual folder icon to prevent other user interaction with the
     * same folder this ensures icon and object hasChildsValue are consistent
     */
    public void evaluesFolderIcon(TreeItem item) {
        GWTFolder folderItem = (GWTFolder) item.getUserObject();
        preventFolderInconsitences(item);

        // On case folder is subscribed mus change icon
        String subscribed = "";
        if (folderItem.isSubscribed()) {
            subscribed = "_subscribed";
        }

        // Looks if must change icon on parent if now has no childs and
        // properties with user security atention
        if ((folderItem.getPermissions() & GWTPermission.WRITE) == GWTPermission.WRITE) {
            if (folderItem.isHasChildren()) {
                item.setHTML(Util.imageItemHTML("img/menuitem_childs" + subscribed + ".gif", folderItem.getName(),
                        "top"));
            } else {
                item.setHTML(Util.imageItemHTML("img/menuitem_empty" + subscribed + ".gif", folderItem.getName(),
                        "top"));
            }
        } else {
            if (folderItem.isHasChildren()) {
                item.setHTML(Util.imageItemHTML("img/menuitem_childs_ro" + subscribed + ".gif",
                        folderItem.getName(), "top"));
            } else {
                item.setHTML(Util.imageItemHTML("img/menuitem_empty_ro" + subscribed + ".gif", folderItem.getName(),
                        "top"));
            }
        }
    }

    /**
     * Prevents folder incosistences between server ( multi user deletes folder
     * ) and tree nodes drawed
     * 
     * @param item
     *            The tree node
     */
    public void preventFolderInconsitences(TreeItem item) {
        GWTFolder folderItem = (GWTFolder) item.getUserObject();

        // Case that must remove all items node
        if (item.getChildCount() > 0 && !folderItem.isHasChildren()) {
            while (item.getChildCount() > 0) {
                item.getChild(0).remove();
            }
        }

        if (item.getChildCount() < 1 && !folderItem.isHasChildren()) {
            folderItem.setHasChildren(false);
        }
    }

    /**
     * Shows the directory select popup
     */
    public void showDirectorySelectPopup() {
        hideMenuPopup();
        folderSelectPopup.show();
    }

    public void showDirectorySelectPopup1() {
        hideMenuPopup();
        folderSelectPopup1.setWidth("450");
        folderSelectPopup1.setHeight("440");
        folderSelectPopup1.setStyleName("okm-Popup");
        folderSelectPopup1.show();
    }

    /**
     * Return true if actualItem selected is root node, other case false
     * 
     * @return value true or false on actualItem to root node comparation
     */
    public boolean isActualItemRoot() {
        if (((GWTFolder) actualItem.getUserObject()).getPath().equals(folderRoot.getPath())) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Indicates if panel is selected
     * 
     * @return The value of panel ( selected )
     */
    public boolean isPanelSelected() {
        return panelSelected;
    }

    /**
     * Sets the selected panel value
     * 
     * @param selected
     *            The selected panel value
     */
    public void setSelectedPanel(boolean selected) {

        // Case panel is not still selected and must enable this and disable
        // browser panel
        if (!isPanelSelected() && selected) {
            Main.get().mainPanel.desktop.browser.fileBrowser.setSelectedPanel(false);
        }

        // Before making other operation must change value of panel selected
        panelSelected = selected;

        if (selected) {
            addStyleName("okm-PanelSelected");
        } else {
            removeStyleName("okm-PanelSelected");
        }
    }

    /**
     * Used only on changing stack
     */
    public void forceSetSelectedPanel() {
        panelSelected = false;
        setSelectedPanel(true);
    }

    /**
     * Hides the menu Popup
     */
    public void hideMenuPopup() {
        if (menuPopup != null) {
            menuPopup.hide();
        }
    }

    /**
     * Evaluates the special case when creating or renaming a folder, user
     * changes to other active view or active panel to create folder or remove
     * the tmp folder
     */
    public void evaluateSpecialTmpFolderCases() {
        if (folderAction == ACTION_CREATE) {
            FolderTextBox folder = (FolderTextBox) actualItem.getWidget();
            if (folder.getText().length() > 0) {
                create(folder.getText());
            } else {
                removeTmpFolderCreate();
            }
        }
    }

    /**
     * Indicates if is folder creating
     * 
     * @return The boolean value if is folder creating
     */
    public boolean isFolderCreating() {
        return (folderAction == ACTION_CREATE);
    }

    /**
     * Indicates if is folder renaming
     * 
     * @return The boolean value if is folder renaming
     */
    public boolean isFolderRenaming() {
        return (folderAction == ACTION_RENAME);
    }

    /**
     * Gets the actual folder action
     * 
     * @return The boolean folder action
     */
    public int getFolderAction() {
        return folderAction;
    }

    /**
     * Refresh for security changes on actual tree node selected ( icon color )
     * only refresh the actual
     */
    public void securityRefresh() {
        folderAction = ACTION_SECURITY_REFRESH; // To make tab properties
        // refresh after get folder
        get();
    }

    /**
     * Refresh tree iten values when tree folder is changed ( normally on file
     * browser, or by security ).
     * 
     * @param folder
     *            The new folder values
     */
    public void refreshChildValues(GWTFolder folder) {
        TreeItem tmpItem;
        GWTFolder gWTFolder;

        if (actualItem.getChildCount() > 0) {
            boolean found = false;
            int i = 0;

            while (!found && i < actualItem.getChildCount()) {
                tmpItem = actualItem.getChild(i);
                gWTFolder = (GWTFolder) tmpItem.getUserObject();
                if (folder.getPath().equals(gWTFolder.getPath())) {
                    tmpItem.setUserObject(folder);
                    evaluesFolderIcon(tmpItem);
                    found = true;
                }
                i++;
            }
        }
    }

    /**
     * Gets the actual folder
     * 
     * @return The parent folder
     */
    public GWTFolder getFolder() {
        return (GWTFolder) actualItem.getUserObject();
    }

    /**
     * getParentFolder
     * 
     * @return
     */
    public GWTFolder getParentFolder() {
        if (actualItem != rootItem) {
            return (GWTFolder) actualItem.getParentItem().getUserObject();
        } else {
            return (GWTFolder) actualItem.getUserObject();
        }
    }

    /**
     * elementClicked
     * 
     * Returns the treeItem when and element is clicked, used to capture drag
     * and drop tree Item
     * 
     * @param element
     * @return
     */
    public TreeItem elementClicked(Element element) {
        return tree.elementClicked(element);
    }

    /**
     * Change recursivelly all the childs path
     * 
     * @param oldPath
     *            The old path
     * @param newPath
     *            The new path
     * @param itemToChange
     *            The tree item to change the path
     */
    public void changePathBeforeRenaming(String oldPath, String newPath, TreeItem itemToChange) {
        for (int i = 0; i < itemToChange.getChildCount(); i++) {
            TreeItem tmpItem = itemToChange.getChild(i);
            GWTFolder gwtFolder = ((GWTFolder) tmpItem.getUserObject());
            gwtFolder.setPath(gwtFolder.getPath().replaceAll(oldPath, newPath));
            gwtFolder.setParentPath(gwtFolder.getParentPath().replaceAll(oldPath, newPath));
            if (tmpItem.getChildCount() > 0) {
                changePathBeforeRenaming(oldPath, newPath, tmpItem);
            }
        }
    }

    /**
     * Sets the home
     */
    public void setHome() {
        GWTFolder folder = (GWTFolder) actualItem.getUserObject();
        Main.get().mainPanel.topPanel.mainMenu.bookmark.confirmSetHome(folder.getUuid(), folder.getPath(), false);
    }

    /**
     * Confirm the purge
     */
    public void confirmPurge() {
        Main.get().confirmPopup.setConfirm(ConfirmPopup.CONFIRM_PURGE_FOLDER);
        Main.get().confirmPopup.show();
    }

    /**
     * Confirm if really wants to purge trash
     */
    public void confirmPurgeTrash() {
        Main.get().confirmPopup.setConfirm(ConfirmPopup.CONFIRM_EMPTY_TRASH);
        Main.get().confirmPopup.show();
    }

    /**
     * Refresh asyncronous subtree branch after an item menu is purged
     */
    final AsyncCallback<Object> callbackPurge = new AsyncCallback<Object>() {
        public void onSuccess(Object result) {
            TreeItem tmpItem = actualItem;
            actualItem = actualItem.getParentItem();
            actualItem.setSelected(true);
            actualItem.setState(true);
            actualItem.removeItem(tmpItem);
            evaluesFolderIcon(actualItem);
            showTabFolderProperties();
            Main.get().mainPanel.desktop.navigator.status.unsetFlagPurge();
            refresh(true);
        }

        public void onFailure(Throwable caught) {
            Main.get().mainPanel.desktop.navigator.status.unsetFlagPurge();
            Main.get().showError("Purge", caught);
        }
    };

    /**
     * Refresh asyncronous subtree branch after all trash is purged
     */
    final AsyncCallback<Object> callbackPurgeTrash = new AsyncCallback<Object>() {
        public void onSuccess(Object result) {
            actualItem = rootItem;
            actualItem.setSelected(true);
            actualItem.setState(true);
            evaluesFolderIcon(actualItem);
            showTabFolderProperties();
            while (actualItem.getChildCount() > 0) {
                actualItem.removeItems();
            }
            Main.get().workspaceUserProperties.getUserDocumentsSize();
            Main.get().mainPanel.desktop.navigator.status.unsetFlagPurgeTrash();
            // After purge trash must refresh desktop
            Main.get().mainPanel.topPanel.toolBar.executeRefresh();
        }

        public void onFailure(Throwable caught) {
            Main.get().mainPanel.desktop.navigator.status.unsetFlagPurgeTrash();
            Main.get().showError("PurgeTrash", caught);
        }
    };

    /**
     * Purge folder on file browser ( only trash mode )
     */
    public void purge() {
        String path = ((GWTFolder) actualItem.getUserObject()).getPath();
        folderService.purge(path, callbackPurge);
        Main.get().mainPanel.desktop.navigator.status.setFlagPurge();
    }

    /**
     * Purge all trash ( only trash mode )
     */
    public void purgeTrash() {
        repositoryService.purgeTrash(callbackPurgeTrash);
        Main.get().mainPanel.desktop.navigator.status.setFlagPurgeTrash();
    }

    /**
     * Restore folder on file browser ( only trash mode )
     */
    public void restore() {
        GWTFolder folderToRestore = (GWTFolder) actualItem.getUserObject();
        folderSelectPopup.setEntryPoint(FolderSelectPopup.ENTRYPOINT_TAXONOMY);
        folderSelectPopup.setToRestore(folderToRestore);
        showDirectorySelectPopup();
    }

    /**
     * Center the actual item on scroll
     * 
     * @param item
     *            The item to show visible
     */
    private void centerActualItemOnScroll(TreeItem item) {
        Main.get().mainPanel.desktop.navigator.scrollTaxonomyPanel.ensureVisible(item);
    }

    /**
     * Centers the actualItem on scroll
     */
    public void centerActulItemOnScroll() {
        Main.get().mainPanel.desktop.navigator.scrollTaxonomyPanel.ensureVisible(actualItem);
    }

    /**
     * Export to file
     */
    public void exportFolderToFile() {
        Util.downloadFileByUUID(getFolder().getUuid(), "export");
    }

    /**
     * Export document list of a folder to excel
     */
    public void exportToExcel() {
        Util.exportToExcel(getFolder().getPath(), "exportToExcel");
    }

    /**
     * disableDragged
     */
    public void disableDragged() {
        tree.disableDragged();
    }

    public void fileBrowserRefreshDone() {
        flagFileBrowserFinished = true;
    }
}