1111 lines
32 KiB
Java
1111 lines
32 KiB
Java
package org.gcube.portlets.user.workspace.client.view.tree;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import org.gcube.portlets.user.workspace.client.AppControllerExplorer;
|
|
import org.gcube.portlets.user.workspace.client.ConstantsExplorer;
|
|
import org.gcube.portlets.user.workspace.client.constant.WorkspaceOperation;
|
|
import org.gcube.portlets.user.workspace.client.event.ExpandFolderEvent;
|
|
import org.gcube.portlets.user.workspace.client.event.MoveItemEvent;
|
|
import org.gcube.portlets.user.workspace.client.event.SelectedItemEvent;
|
|
import org.gcube.portlets.user.workspace.client.event.SessionExpiredEvent;
|
|
import org.gcube.portlets.user.workspace.client.model.FileModel;
|
|
import org.gcube.portlets.user.workspace.client.model.FolderModel;
|
|
import org.gcube.portlets.user.workspace.client.resources.Resources;
|
|
import org.gcube.portlets.user.workspace.client.view.windows.MessageBoxAlert;
|
|
import org.gcube.portlets.user.workspace.shared.SessionExpiredException;
|
|
|
|
import com.extjs.gxt.ui.client.Style.SelectionMode;
|
|
import com.extjs.gxt.ui.client.data.ModelData;
|
|
import com.extjs.gxt.ui.client.data.ModelIconProvider;
|
|
import com.extjs.gxt.ui.client.dnd.DND.Feedback;
|
|
import com.extjs.gxt.ui.client.dnd.Insert;
|
|
import com.extjs.gxt.ui.client.dnd.TreePanelDragSource;
|
|
import com.extjs.gxt.ui.client.dnd.TreePanelDropTarget;
|
|
import com.extjs.gxt.ui.client.event.ButtonEvent;
|
|
import com.extjs.gxt.ui.client.event.ComponentEvent;
|
|
import com.extjs.gxt.ui.client.event.DNDEvent;
|
|
import com.extjs.gxt.ui.client.event.DNDListener;
|
|
import com.extjs.gxt.ui.client.event.EventType;
|
|
import com.extjs.gxt.ui.client.event.Events;
|
|
import com.extjs.gxt.ui.client.event.Listener;
|
|
import com.extjs.gxt.ui.client.event.MenuEvent;
|
|
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
|
|
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
|
|
import com.extjs.gxt.ui.client.event.TreePanelEvent;
|
|
import com.extjs.gxt.ui.client.store.Record;
|
|
import com.extjs.gxt.ui.client.store.Store;
|
|
import com.extjs.gxt.ui.client.store.StoreSorter;
|
|
import com.extjs.gxt.ui.client.store.TreeStore;
|
|
import com.extjs.gxt.ui.client.store.TreeStoreModel;
|
|
import com.extjs.gxt.ui.client.widget.Component;
|
|
import com.extjs.gxt.ui.client.widget.ContentPanel;
|
|
import com.extjs.gxt.ui.client.widget.LayoutContainer;
|
|
import com.extjs.gxt.ui.client.widget.button.Button;
|
|
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
|
|
import com.extjs.gxt.ui.client.widget.treepanel.TreePanel;
|
|
import com.extjs.gxt.ui.client.widget.treepanel.TreePanel.TreeNode;
|
|
import com.google.gwt.core.client.GWT;
|
|
import com.google.gwt.event.shared.EventHandler;
|
|
import com.google.gwt.event.shared.HandlerManager;
|
|
import com.google.gwt.user.client.Event;
|
|
import com.google.gwt.user.client.rpc.AsyncCallback;
|
|
import com.google.gwt.user.client.ui.AbstractImagePrototype;
|
|
|
|
|
|
/**
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
*/
|
|
public class AsyncTreePanel extends LayoutContainer {
|
|
|
|
private static final String TREE_MESSAGE_PANEL_ASYNC = "treeMessagePanelAsync";
|
|
|
|
private static final String ROOT_SUFFIX = "'s workspace";
|
|
// private TreeLoader<FileModel> loader;
|
|
private TreePanel<FileModel> treePanel;
|
|
private TreeStore<FileModel> store;
|
|
private ContextMenuTree contextMenuTree;
|
|
private HandlerManager eventBus = AppControllerExplorer.getEventBus();
|
|
private ContentPanel cp = new ContentPanel();
|
|
private boolean isSubTreeLoaded = false;
|
|
private boolean isSearch = false;
|
|
private String scopeId = null;
|
|
private enum DragType {INSERT, APPEND};
|
|
// private int contextMenuPosX = -1;
|
|
// private int contextMenuPosY = -1;
|
|
|
|
private boolean rightClick = false;
|
|
|
|
public AsyncTreePanel() {
|
|
|
|
//Init Store
|
|
store = new TreeStore<FileModel>();
|
|
|
|
//Load Root Item
|
|
// this.loadRootItem();
|
|
|
|
treePanel = new TreePanel<FileModel>(store){
|
|
@Override
|
|
public boolean hasChildren(FileModel parent) {
|
|
if (parent instanceof FolderModel) {
|
|
return true;
|
|
}
|
|
return super.hasChildren(parent);
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings({"unchecked", "rawtypes"})
|
|
public void onComponentEvent(ComponentEvent ce) {
|
|
super.onComponentEvent(ce);
|
|
TreePanelEvent<FileModel> tpe = (TreePanelEvent) ce;
|
|
EventType typeEvent = tpe.getType();
|
|
|
|
rightClick = false;
|
|
|
|
if (typeEvent == Events.OnMouseDown) {
|
|
|
|
if (ce.isRightClick()){
|
|
rightClick = true;
|
|
}
|
|
}
|
|
|
|
int type = ce.getEventTypeInt();
|
|
switch (type) {
|
|
case Event.ONCLICK:
|
|
onClick(tpe);
|
|
break;
|
|
case Event.ONDBLCLICK:
|
|
onDoubleClick(tpe);
|
|
break;
|
|
case Event.ONSCROLL:
|
|
onScroll(tpe);
|
|
break;
|
|
case Event.ONFOCUS:
|
|
onFocus(ce);
|
|
break;
|
|
}
|
|
|
|
view.onEvent(tpe);
|
|
}
|
|
};
|
|
|
|
|
|
treePanel.setStateful(false);
|
|
treePanel.setDisplayProperty(ConstantsExplorer.NAME);
|
|
|
|
// statefull components need a defined id
|
|
treePanel.setId(TREE_MESSAGE_PANEL_ASYNC);
|
|
|
|
// SET icons in tree panel
|
|
treePanel.setIconProvider(new ModelIconProvider<FileModel>() {
|
|
|
|
public AbstractImagePrototype getIcon(FileModel model) {
|
|
// model.setIcon();
|
|
if (!model.isDirectory()) {
|
|
if(model.getType()!=null)
|
|
return Resources.getIconByType(model.getName(), model.getType());
|
|
|
|
return Resources.getIconByFolderItemType(model.getGXTFolderItemType());
|
|
}
|
|
if (model.isRoot()) {
|
|
model.setName(AppControllerExplorer.myLoginFirstName+ROOT_SUFFIX);
|
|
return Resources.getCloudDriveIcon();
|
|
}
|
|
|
|
if(model.getStatus() == ConstantsExplorer.FOLDERNOTLOAD)
|
|
return Resources.getIconLoading2();
|
|
|
|
if(model.isVreFolder())
|
|
return Resources.getIconVREFolder();
|
|
|
|
if(model.isSpecialFolder())
|
|
return Resources.getIconSpecialFolder();
|
|
|
|
//SHARE ICON
|
|
if(model.isShared()){
|
|
if(model.isShareable())
|
|
return Resources.getIconSharedFolder();
|
|
else
|
|
return null; //Set default folder icon
|
|
}
|
|
return null; //Set default folder icon
|
|
}
|
|
});
|
|
|
|
contextMenuTree = new ContextMenuTree();
|
|
|
|
treePanel.setContextMenu(contextMenuTree.getContextMenu());
|
|
|
|
//Single selection Mode
|
|
treePanel.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
|
|
|
|
this.addListners();
|
|
this.addDragAndDrop();
|
|
this.setAlphanumericStoreSorter();
|
|
|
|
cp.setHeading(ConstantsExplorer.TREEVIEW);
|
|
cp.setHeaderVisible(false);
|
|
|
|
// //BULK
|
|
// Header headerCp = cp.getHeader();
|
|
// buttBulk.setIcon(Resources.getIconBulkUpdate());
|
|
// headerCp.addTool(buttBulk);
|
|
|
|
cp.setBodyBorder(false);
|
|
cp.setBodyStyle("padding: 5px");
|
|
cp.setLayout(new FitLayout());
|
|
|
|
//***For Debug the store
|
|
Button butt = new Button();
|
|
butt.setText("Print Store");
|
|
butt.setVisible(false);
|
|
|
|
butt.addListener(Events.OnClick, new Listener<ButtonEvent>() {
|
|
|
|
@Override
|
|
public void handleEvent(ButtonEvent be) {
|
|
List<FileModel> listFileModel = treePanel.getStore().getRootItems();
|
|
System.out.println("\n\nStore by root");
|
|
|
|
for (FileModel item : listFileModel) {
|
|
System.out.println(item.getName() + " ID " + item.getIdentifier() + " isDirectory " + item.isDirectory());
|
|
|
|
// eventBus.fireEvent(new SelectedItemEvent(treePanel.getStore().getRootItems().get(0)));
|
|
printingTreeLevel(item);
|
|
}
|
|
}
|
|
|
|
});
|
|
|
|
// cp.add(butt);
|
|
|
|
//***End Debug the store
|
|
|
|
cp.add(treePanel);
|
|
|
|
add(cp);
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
* Status values
|
|
* ConstantsExplorer.FOLDERNOTLOAD = "notload";
|
|
* ConstantsExplorer.FOLDERLOADED = "loaded";
|
|
*
|
|
* @param itemIdentifier
|
|
* @param status
|
|
*/
|
|
|
|
public void changeFolderIconStatus(String itemIdentifier, String status){
|
|
|
|
FileModel fileModel = getFileModelByIdentifier(itemIdentifier);
|
|
fileModel.setStatus(status);
|
|
}
|
|
|
|
|
|
public void loadRootItem(String scopeId, final boolean selectRoot){
|
|
|
|
this.scopeId = scopeId;
|
|
|
|
System.out.println("***Start Root load with scopeid: " + scopeId);
|
|
|
|
|
|
if(this.scopeId !=null){
|
|
//Load Root with specific scope id
|
|
AppControllerExplorer.rpcWorkspaceService.getRootForTree(scopeId, new AsyncCallback<FolderModel>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " getting root item. " +ConstantsExplorer.TRY_AGAIN, null);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(FolderModel result) {
|
|
loadRootInStore(result, selectRoot);
|
|
|
|
}
|
|
});
|
|
}
|
|
|
|
else{
|
|
//Load Root without filtering on scope id
|
|
AppControllerExplorer.rpcWorkspaceService.getRootForTree(new AsyncCallback<FolderModel>() {
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " getting root item. " +ConstantsExplorer.TRY_AGAIN, null);
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(FolderModel result) {
|
|
loadRootInStore(result, selectRoot);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
private void loadRootInStore(FolderModel root, boolean selectRootOnLoad){
|
|
|
|
if(root!=null){
|
|
store.removeAll();
|
|
store.insert(root, 0, false);
|
|
System.out.println("Root Name: " + store.getRootItems().get(0).get(ConstantsExplorer.NAME));
|
|
treePanel.setExpanded(store.getRootItems().get(0),true); //expand level 1
|
|
if(selectRootOnLoad)
|
|
selectRootItem(); //select root item
|
|
|
|
System.out.println("***End Root load ");
|
|
}
|
|
else
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " getting root item. Root item is null " +ConstantsExplorer.TRY_AGAIN, null);
|
|
|
|
}
|
|
|
|
private void addDragAndDrop() {
|
|
|
|
//Drag & Drop Event
|
|
TreePanelDragSource source = new TreePanelDragSource(treePanel);
|
|
source.addDNDListener(new DNDListener() {
|
|
@Override
|
|
public void dragStart(DNDEvent event) {
|
|
|
|
GWT.log("***Event Start drag");
|
|
FileModel sel = treePanel.getSelectionModel().getSelectedItem();
|
|
|
|
if (sel != null && sel == treePanel.getStore().getRootItems().get(0)) {
|
|
event.setCancelled(true);
|
|
event.getStatus().setStatus(false);
|
|
return;
|
|
}
|
|
|
|
if(sel.isVreFolder() || sel.isSpecialFolder()){
|
|
event.setCancelled(true);
|
|
event.getStatus().setStatus(false);
|
|
return;
|
|
}
|
|
|
|
if(sel != null && sel.getName()!= null)
|
|
GWT.log("Start drag of " + sel.getName());
|
|
|
|
super.dragStart(event);
|
|
}
|
|
});
|
|
|
|
|
|
TreePanelDropTarget targetTreePanel = new TreePanelDropTarget(treePanel){
|
|
// @Override
|
|
// protected void onDragDrop(DNDEvent event) {
|
|
// System.out.println("on Drop");
|
|
// super.onDragDrop(event);
|
|
// }
|
|
|
|
// @Override
|
|
// protected void showFeedback(DNDEvent event) {
|
|
// // TODO Auto-generated method stub
|
|
// super.showFeedback(event);
|
|
//
|
|
// }
|
|
|
|
@Override
|
|
protected void showFeedback(DNDEvent event) {
|
|
if (!isValidDropTarget(event)) {
|
|
Insert.get().hide();
|
|
event.getStatus().setStatus(false);
|
|
return;
|
|
}
|
|
super.showFeedback(event);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private boolean isValidDropTarget(DNDEvent event) {
|
|
TreePanel<FileModel> target = (TreePanel<FileModel>) event.getDropTarget().getComponent();
|
|
TreePanel<FileModel>.TreeNode zone = target.findNode(event.getTarget());
|
|
|
|
if (zone == null) {
|
|
return true; // let it check from super-class
|
|
}
|
|
|
|
Component com = event.getDragSource().getComponent();
|
|
|
|
if(com instanceof TreePanel<?>){
|
|
|
|
TreePanel<FileModel> source = (TreePanel<FileModel>) event.getDragSource().getComponent();
|
|
List<FileModel> selection = source.getSelectionModel().getSelection();
|
|
|
|
for (FileModel model : selection) {
|
|
// check the "model" against "zone" and return false
|
|
// if "zone" is not a valid drop target for "model", otherwise check the next "model"
|
|
// example:
|
|
if (source.getStore().getParent(model) == zone.getModel())
|
|
return false;
|
|
|
|
// if(source.getStore().getParent(model) == target.getModel())
|
|
// return false;
|
|
|
|
if(zone.getModel().isSpecialFolder()) //NOT DROPPABLE INTO SPECIAL FOLDER
|
|
return false;
|
|
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
// TreePanel<FileModel> source = (TreePanel<FileModel>) event.getDragSource().getComponent();
|
|
// List<FileModel> selection = source.getSelectionModel().getSelection();
|
|
//
|
|
// for (FileModel model : selection) {
|
|
// // check the "model" against "zone" and return false
|
|
// // if "zone" is not a valid drop target for "model", otherwise check the next "model"
|
|
// // example:
|
|
// if (source.getStore().getParent(model) == zone.getModel())
|
|
// return false;
|
|
//
|
|
//// if(source.getStore().getParent(model) == target.getModel())
|
|
//// return false;
|
|
// }
|
|
//
|
|
// return true;
|
|
}
|
|
|
|
//Called when drop on folder
|
|
@Override
|
|
protected void handleAppendDrop(DNDEvent event, @SuppressWarnings("rawtypes") TreeNode item) {
|
|
super.handleAppendDrop(event, item);
|
|
|
|
GWT.log("***Event move handleAppendDrop");
|
|
List<FileModel> listFileModel = getDragSource(event);
|
|
|
|
if(listFileModel.size() == 1){
|
|
FileModel destination = getDragDestination(item, DragType.APPEND);
|
|
if(destination != null){
|
|
//REMOVE THIS COMMENT TODO
|
|
eventBus.fireEvent(new MoveItemEvent(listFileModel.get(0), (FolderModel) destination));
|
|
System.out.println("Destination: " +destination.getName() + " id "+ destination.getIdentifier());
|
|
}
|
|
}else{
|
|
//MULTIDRAG
|
|
}
|
|
GWT.log("***End Event move handleAppendDrop");
|
|
}
|
|
|
|
// @Override
|
|
// protected void onDragMove(DNDEvent event){
|
|
//// System.out.println("on Drag Move");
|
|
// super.onDragMove(event);
|
|
// }
|
|
|
|
//Called when drop between files
|
|
@Override
|
|
protected void handleInsertDrop(DNDEvent event, @SuppressWarnings("rawtypes") TreeNode item, int index) {
|
|
super.handleInsertDrop(event, item, index);
|
|
|
|
GWT.log("***Event move handleInsertDrop");
|
|
List<FileModel> listFileModel = getDragSource(event);
|
|
if(listFileModel.size() == 1){ //one element dragged
|
|
|
|
FileModel destination = getDragDestination(item, DragType.INSERT);
|
|
if(destination != null){
|
|
GWT.log("Destination: " +destination.getName() + " id "+ destination.getIdentifier());
|
|
//REMOVE THIS COMMENT TODO
|
|
eventBus.fireEvent(new MoveItemEvent(listFileModel.get(0), (FolderModel) destination));
|
|
}
|
|
}else{
|
|
//multi drag
|
|
}
|
|
GWT.log("***End Event move handleInsertDrop");
|
|
}
|
|
|
|
private FileModel getDragDestination(@SuppressWarnings("rawtypes") TreeNode item, DragType insertType){
|
|
|
|
FileModel destination = null;
|
|
if(item!=null){
|
|
destination = (FileModel) item.getModel();
|
|
if(destination != null){
|
|
if(insertType.equals(DragType.APPEND))
|
|
return destination; //APPEND ON FOLDER
|
|
else
|
|
return destination.getParentFileModel(); //INSERT BETWEEN FILE - RETUR FOLDER PARENT
|
|
}
|
|
}
|
|
return destination;
|
|
}
|
|
|
|
private List<FileModel> getDragSource(DNDEvent event){
|
|
|
|
List<FileModel> listDraggedFile = new ArrayList<FileModel>();
|
|
|
|
if(event.getData() != null){
|
|
List<TreeStoreModel> listItemsSource = event.getData();
|
|
GWT.log("Number of move " + listItemsSource.size());
|
|
FileModel sourceFileModel = null; //for print
|
|
|
|
for(TreeStoreModel itemSource : listItemsSource){
|
|
|
|
listDraggedFile.add((FileModel) itemSource.getModel());
|
|
sourceFileModel = (FileModel) itemSource.getModel();
|
|
if(sourceFileModel.getParentFileModel()!=null)
|
|
GWT.log("Source Name " + sourceFileModel.getName() + " id " + sourceFileModel.getIdentifier() + " end drag " + " Parent Name: " + sourceFileModel.getParentFileModel().getName() + "id " + sourceFileModel.getParentFileModel().getIdentifier());
|
|
else
|
|
GWT.log("Source Name " + sourceFileModel.getName() + " id " + sourceFileModel.getIdentifier() + " end drag ");
|
|
|
|
GWT.log("Child count: " + itemSource.getChildCount());
|
|
}
|
|
}
|
|
return listDraggedFile;
|
|
}
|
|
|
|
// @Override
|
|
// protected void handleInsert(DNDEvent event, TreeNode treeNode){
|
|
// super.handleAppend(event, treeNode);
|
|
//// System.out.println("in handle insert");
|
|
// }
|
|
};
|
|
|
|
targetTreePanel.setAllowSelfAsSource(true);
|
|
targetTreePanel.setFeedback(Feedback.APPEND);
|
|
targetTreePanel.setScrollElementId(cp.getId());
|
|
// targetTreePanel.setAllowDropOnLeaf(true);
|
|
}
|
|
|
|
|
|
private void addListners() {
|
|
|
|
treePanel.getSelectionModel().addSelectionChangedListener(new SelectionChangedListener<FileModel>() {
|
|
|
|
@Override
|
|
public void selectionChanged(SelectionChangedEvent<FileModel> objEvent) {
|
|
|
|
FileModel fileModel = objEvent.getSelectedItem();
|
|
|
|
if(rightClick){
|
|
// treePanel.disableEvents(true);
|
|
// deselectItem(fileModel);
|
|
// treePanel.enableEvents(true);
|
|
return;
|
|
}
|
|
|
|
System.out.println("***Event selection change");
|
|
|
|
if(fileModel != null && !isSearch){ //is null on drag & drop event
|
|
|
|
//For printing
|
|
String type;
|
|
if(fileModel.getType()!=null)
|
|
type = fileModel.getType();
|
|
else
|
|
type = "null";
|
|
|
|
//DEBUG
|
|
// String folderItemType;
|
|
// if(fileModel.getGXTFolderItemType()!=null)
|
|
// folderItemType = fileModel.getGXTFolderItemType().toString();
|
|
// else
|
|
// folderItemType = null;
|
|
// if(fileModel.getParentFileModel()!=null)
|
|
// System.out.println("Item selected " + fileModel.getName() + " Id " + fileModel.getIdentifier() + " Parent " + fileModel.getParentFileModel().getName() + " with id " + fileModel.getParentFileModel().getIdentifier() + " IsDirectory " + ""+fileModel.isDirectory() + " type "+ type + " HLFolderItemType "+folderItemType);
|
|
// else
|
|
// System.out.println("Item selected " + fileModel.getName() + " Id " + fileModel.getIdentifier() + " Parent null " + " IsDirectory " + ""+fileModel.isDirectory()+ " type "+ type +" HLFolderItemType "+folderItemType );
|
|
|
|
System.out.println("Item selected" + fileModel);
|
|
|
|
eventBus.fireEvent(new SelectedItemEvent(fileModel));
|
|
|
|
}
|
|
|
|
|
|
System.out.println("***End Event selection change");
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// // Listner on Click
|
|
treePanel.addListener(Events.OnClick, new Listener<TreePanelEvent<ModelData>>() {
|
|
public void handleEvent(TreePanelEvent<ModelData> be) {
|
|
|
|
if(be != null){
|
|
if(isSearch){ //TODO WORK AROUND - used after search
|
|
setSearch(false);
|
|
// FileModel fileModel = (FileModel) be.getNode().getModel();
|
|
// reSelectItem(fileModel.getIdentifier());
|
|
|
|
TreeNode node = be.getNode();
|
|
|
|
if(node!=null){
|
|
FileModel fileModel = (FileModel) be.getNode().getModel();
|
|
reSelectItem(fileModel.getIdentifier());
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
});
|
|
|
|
// // Listner on Menu Hide
|
|
treePanel.getContextMenu().addListener(Events.Hide, new Listener<MenuEvent>() {
|
|
|
|
@Override
|
|
public void handleEvent(MenuEvent be) {
|
|
|
|
if(be!=null)
|
|
deselectItem(treePanel.getSelectionModel().getSelectedItem());
|
|
}
|
|
});
|
|
|
|
|
|
treePanel.addListener(Events.BeforeExpand, new Listener<TreePanelEvent<ModelData>>() {
|
|
public void handleEvent(final TreePanelEvent<ModelData> be) {
|
|
|
|
if(be != null && !isSubTreeLoaded){
|
|
|
|
GWT.log("***Event beforeExpand Node");
|
|
GWT.log("Expand Folder Model: " + be.getNode().getModel().get(ConstantsExplorer.NAME));
|
|
final FolderModel folder = (FolderModel) be.getNode().getModel();
|
|
int numChildrenFolder = store.getChildCount(folder);
|
|
|
|
if (folder!=null){
|
|
eventBus.fireEvent(new ExpandFolderEvent(folder));
|
|
if (numChildrenFolder==0) {
|
|
treePanel.mask(ConstantsExplorer.LOADING,ConstantsExplorer.LOADINGSTYLE);
|
|
loadTreeLevelFromWorkspace(folder);
|
|
}
|
|
}
|
|
GWT.log("***End Event beforeExpand Node");
|
|
}
|
|
}
|
|
});
|
|
|
|
// Add lister to context menu
|
|
treePanel.addListener(Events.ContextMenu, new Listener<TreePanelEvent<FileModel>>() {
|
|
|
|
public void handleEvent(TreePanelEvent<FileModel> be) {
|
|
|
|
GWT.log("***Event Context Menu open");
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
TreeNode node = be.getNode();
|
|
|
|
if(node!=null){
|
|
GWT.log("Menu on: " + node.getModel().get(ConstantsExplorer.NAME));
|
|
GWT.log("node "+ treePanel.findNode(be.getTarget()));
|
|
}else{
|
|
GWT.log("Menu on: null");
|
|
GWT.log("node "+ treePanel.findNode(be.getTarget()));
|
|
}
|
|
List<FileModel> listSelected = treePanel.getSelectionModel().getSelectedItems();
|
|
//
|
|
if (listSelected != null && listSelected.size() > 0) {
|
|
manageContextMenu();
|
|
}
|
|
//
|
|
}
|
|
|
|
|
|
});
|
|
|
|
|
|
}
|
|
|
|
private void manageContextMenu(){
|
|
|
|
System.out.println("***Event Context Menu open");
|
|
|
|
contextMenuTree.setListSelectedItems(treePanel.getSelectionModel().getSelectedItems()); //Set items list selected in context menu tree
|
|
|
|
FileModel selectedItem = treePanel.getSelectionModel().getSelectedItems().get(0); //get first element
|
|
|
|
if (store.getRootItems().get(0).equals(selectedItem)) {//selected root item?
|
|
setVisibleRenameAndRemoveContextMenu(false);
|
|
setVisibileGetWebDavUrl(true);
|
|
}
|
|
else{
|
|
setVisibleRenameAndRemoveContextMenu(true);
|
|
setVisibileGetWebDavUrl(false);
|
|
}
|
|
|
|
contextMenuTree.contextMenuSwitch(selectedItem);
|
|
|
|
System.out.println("***End Event Context Menu open");
|
|
}
|
|
|
|
|
|
public void reloadTreeLevelAndExpandFolder(String folderIdentifier, boolean expandFolder){
|
|
final FolderModel folder = (FolderModel) getFileModelByIdentifier(folderIdentifier);
|
|
reloadTreeLevelAndExpandFolder(folder, expandFolder);
|
|
}
|
|
|
|
public void addItemIdAndExpandFolder(final FileModel parent, String itemId, boolean expandFolder){
|
|
|
|
treePanel.mask(ConstantsExplorer.VALIDATINGOPERATION,ConstantsExplorer.LOADINGSTYLE);
|
|
AppControllerExplorer.rpcWorkspaceService.getItemForFileTree(itemId, new AsyncCallback<FileModel>(){
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
if(caught instanceof SessionExpiredException){
|
|
GWT.log("Session expired");
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
return;
|
|
}
|
|
treePanel.unmask();
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " getting item from workspace." +ConstantsExplorer.TRY_AGAIN, null);
|
|
removeAllAndRecoveryRoot();
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(FileModel result) {
|
|
GWT.log("GetItemForFileTree adding: "+result);
|
|
treePanel.unmask();
|
|
store.add(parent,result,false);
|
|
}
|
|
});
|
|
}
|
|
|
|
private void reloadTreeLevelAndExpandFolder(final FolderModel folder, final boolean expandFolder){
|
|
|
|
treePanel.mask(ConstantsExplorer.VALIDATINGOPERATION,ConstantsExplorer.LOADINGSTYLE);
|
|
AppControllerExplorer.rpcWorkspaceService.getFolderChildren(folder, new AsyncCallback<List<FileModel>>(){
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
if(caught instanceof SessionExpiredException){
|
|
GWT.log("Session expired");
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
return;
|
|
}
|
|
treePanel.unmask();
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " getting folder children items." +ConstantsExplorer.TRY_AGAIN, null);
|
|
removeAllAndRecoveryRoot();
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
treePanel.unmask();
|
|
store.removeAll(folder);
|
|
// addChildrenToFolder(folder.getIdentifier(), result);
|
|
addChildrenToFolder(folder, result);
|
|
setExpandTreeLevel(folder, expandFolder);
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
private void loadTreeLevelFromWorkspace(final FolderModel folder){
|
|
GWT.log("Start RPC - getFolderChildren");
|
|
// Log.info("Start RPC - getFolderChildren");
|
|
// final CountTimer count = new CountTimer(1000);
|
|
|
|
AppControllerExplorer.rpcWorkspaceService.getFolderChildren(folder, new AsyncCallback<List<FileModel>>(){
|
|
|
|
@Override
|
|
public void onFailure(Throwable caught) {
|
|
|
|
if(caught instanceof SessionExpiredException){
|
|
GWT.log("Session expired");
|
|
eventBus.fireEvent(new SessionExpiredEvent());
|
|
return;
|
|
}
|
|
|
|
new MessageBoxAlert("Error", ConstantsExplorer.SERVER_ERROR + " getting folder children items. " +ConstantsExplorer.TRY_AGAIN, null);
|
|
removeAllAndRecoveryRoot();
|
|
}
|
|
|
|
@Override
|
|
public void onSuccess(List<FileModel> result) {
|
|
if(treePanel.isMasked())
|
|
treePanel.unmask();
|
|
|
|
store.removeAll(folder);
|
|
addChildrenToFolder(folder, result);
|
|
GWT.log("End RPC - getFolderChildren");
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
public void addChildrenToFolder(String idParent, List<FileModel> children){
|
|
|
|
FileModel parent = getFileModelByIdentifier(idParent);
|
|
if(parent!=null)
|
|
store.add(parent,children,false);
|
|
|
|
}
|
|
|
|
private void addChildrenToFolder(FolderModel parent, List<FileModel> children){
|
|
|
|
if(parent!=null){
|
|
store.add(parent,children,false);
|
|
System.out.println("Added children in store");
|
|
}
|
|
}
|
|
|
|
private void setVisibleRenameAndRemoveContextMenu(boolean bool){
|
|
|
|
treePanel.getContextMenu().getItemByItemId(WorkspaceOperation.REMOVE.getId()).setVisible(bool);
|
|
treePanel.getContextMenu().getItemByItemId(WorkspaceOperation.RENAME.getId()).setVisible(bool);
|
|
|
|
}
|
|
|
|
private void setVisibileGetWebDavUrl(boolean bool){
|
|
treePanel.getContextMenu().getItemByItemId(WorkspaceOperation.WEBDAV_URL.getId()).setVisible(bool);
|
|
}
|
|
|
|
private void setAlphanumericStoreSorter(){
|
|
|
|
// Sorting files
|
|
store.setStoreSorter(new StoreSorter<FileModel>() {
|
|
|
|
@Override
|
|
public int compare(Store<FileModel> store, FileModel m1, FileModel m2, String property) {
|
|
boolean m1Folder = m1 instanceof FolderModel;
|
|
boolean m2Folder = m2 instanceof FolderModel;
|
|
|
|
if (m1Folder && !m2Folder) {
|
|
return -1;
|
|
} else if (!m1Folder && m2Folder) {
|
|
return 1;
|
|
}
|
|
|
|
if(m1.isSpecialFolder() && !m2.isSpecialFolder())
|
|
return -1;
|
|
else if(!m1.isSpecialFolder() && m2.isSpecialFolder())
|
|
return 1;
|
|
|
|
return m1.getName().compareToIgnoreCase(m2.getName());
|
|
}
|
|
});
|
|
}
|
|
|
|
//TODO for debug
|
|
private void printingTreeLevel(FileModel item){
|
|
|
|
List<FileModel> children = treePanel.getStore().getChildren(item);
|
|
|
|
if (children != null) {
|
|
|
|
for (FileModel item2 : children) {
|
|
|
|
System.out.println(" " + item2.getName() + " ID " + item2.getIdentifier() + " isDirectory " + item.isDirectory());
|
|
|
|
printingTreeLevel(item2);
|
|
}
|
|
|
|
System.out.println(" ");
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param identifier
|
|
* @return
|
|
*/
|
|
public FileModel getFileModelByIdentifier(String identifier){
|
|
|
|
return treePanel.getStore().findModel(ConstantsExplorer.IDENTIFIER, identifier);
|
|
}
|
|
|
|
public int getChildrenNumber(String identifier){
|
|
|
|
FolderModel fileModel = (FolderModel) getFileModelByIdentifier(identifier);
|
|
return getChildrenNumber(fileModel);
|
|
}
|
|
|
|
private int getChildrenNumber(FolderModel folder){
|
|
|
|
return store.getChildCount(folder);
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param identifier (MANDATORY)
|
|
* @return
|
|
*/
|
|
public boolean deleteItem(String identifier) {
|
|
|
|
FileModel fileTarget = getFileModelByIdentifier(identifier);
|
|
|
|
if(fileTarget!=null){
|
|
return deleteItem(fileTarget);
|
|
}
|
|
else
|
|
System.out.println("Delete Error: file target with " + identifier + " identifier not exist in store" );
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param fileTarget (MANDATORY)
|
|
* @param newName (MANDATORY)
|
|
* @param extension OPTIONAL - string or null
|
|
*/
|
|
private boolean renameItem(FileModel fileTarget, String newName, String extension) {
|
|
|
|
if(fileTarget!=null){
|
|
Record record = treePanel.getStore().getRecord(fileTarget);
|
|
if(record!=null){
|
|
if(extension!= null)
|
|
record.set(ConstantsExplorer.NAME, newName+extension);
|
|
else
|
|
record.set(ConstantsExplorer.NAME, newName);
|
|
|
|
return true;
|
|
}
|
|
else
|
|
System.out.println("Record Error: file target with " + fileTarget.getIdentifier() + " identifier not exist in store" );
|
|
}
|
|
else
|
|
System.out.println("Rename Error: file target not exist in store" );
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param fileTarget (MANDATORY)
|
|
* @param newName (MANDATORY)
|
|
* @param extension OPTIONAL - string or null
|
|
*/
|
|
public boolean renameItem(String identifier, String newName, String extension) {
|
|
|
|
// FileModel fileTarget = treePanel.getStore().findModel(ConstantsExplorer.IDENTIFIER, identifier);
|
|
|
|
FileModel fileTarget = getFileModelByIdentifier(identifier);
|
|
|
|
return renameItem(fileTarget,newName,extension);
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param fileTarget (MANDATORY)
|
|
* @return
|
|
*/
|
|
private boolean deleteItem(FileModel fileTarget) {
|
|
|
|
Record record = treePanel.getStore().getRecord(fileTarget);
|
|
|
|
if (record != null) {
|
|
|
|
FileModel item = (FileModel) record.getModel();
|
|
treePanel.getStore().remove(item);
|
|
|
|
return true;
|
|
} else
|
|
System.out.println("Record Error: file target with "
|
|
+ fileTarget.getIdentifier()
|
|
+ " identifier not exist in store");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
public void addItem(String parentId, FileModel child, boolean bool) {
|
|
FileModel parent = getFileModelByIdentifier(parentId);
|
|
if(parent!=null)
|
|
addItem(parent,child,bool);
|
|
}
|
|
|
|
|
|
private void addItem(FileModel parent, FileModel child, boolean bool) {
|
|
store.add(parent, child, bool);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param parent
|
|
* @param bool expand true/false
|
|
*/
|
|
private void setExpandTreeLevel(FileModel parent, boolean bool) {
|
|
treePanel.setExpanded(parent, bool);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param identifier
|
|
* @return
|
|
*/
|
|
public boolean isExpanded(String identifier){
|
|
|
|
if(identifier==null)
|
|
return false;
|
|
|
|
|
|
FileModel fileTarget = getFileModelByIdentifier(identifier);
|
|
|
|
if(fileTarget==null)
|
|
return false;
|
|
|
|
return treePanel.isExpanded(fileTarget);
|
|
}
|
|
|
|
public void setExpandTreeLevel(String identifier, boolean bool) {
|
|
FileModel item = getFileModelByIdentifier(identifier);
|
|
if(item!=null)
|
|
treePanel.setExpanded(item, bool);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param identifier
|
|
* @return
|
|
*/
|
|
public boolean selectItem(String identifier){
|
|
|
|
FileModel fileTarget = getFileModelByIdentifier(identifier);
|
|
if(fileTarget!=null){
|
|
treePanel.getSelectionModel().select(fileTarget, true); //Select the item
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean reSelectItem(String identifier){
|
|
|
|
FileModel fileTarget = getFileModelByIdentifier(identifier);
|
|
if(fileTarget!=null){
|
|
treePanel.getSelectionModel().deselect(fileTarget);
|
|
treePanel.getSelectionModel().select(fileTarget, true); //Select the item
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
private boolean selectItem(FileModel fileTarget){
|
|
|
|
if(fileTarget!=null){
|
|
treePanel.getSelectionModel().select(fileTarget, true); //Select the item
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isSubTreeLoaded() {
|
|
return isSubTreeLoaded;
|
|
}
|
|
|
|
public void setSubTreeLoaded(boolean isSubTreeLoaded) {
|
|
this.isSubTreeLoaded = isSubTreeLoaded;
|
|
}
|
|
|
|
/**
|
|
* Select root by default
|
|
*/
|
|
public void removeAllAndRecoveryRoot(){
|
|
store.removeAll();
|
|
loadRootItem(scopeId,true);
|
|
}
|
|
|
|
public void removeAllAndRecoveryRoot(boolean selectRoot){
|
|
store.removeAll();
|
|
loadRootItem(scopeId,selectRoot);
|
|
}
|
|
|
|
public void selectRootItem(){
|
|
FileModel selectedItem = treePanel.getSelectionModel().getSelectedItem();
|
|
if(selectedItem!=null)
|
|
treePanel.getSelectionModel().deselect(selectedItem);
|
|
|
|
treePanel.getSelectionModel().select(store.getRootItems().get(0), true); //select root item
|
|
}
|
|
|
|
public void deselectItem(String identifier){
|
|
FileModel fileTarget = getFileModelByIdentifier(identifier);
|
|
if(fileTarget!=null)
|
|
treePanel.getSelectionModel().deselect(fileTarget);
|
|
}
|
|
|
|
public void deselectItem(FileModel fileTarget){
|
|
if(fileTarget!=null)
|
|
treePanel.getSelectionModel().deselect(fileTarget);
|
|
}
|
|
|
|
public FileModel getSelectedFileModelItem(){
|
|
FileModel selectedItem = treePanel.getSelectionModel().getSelectedItem();
|
|
if(selectedItem!=null)
|
|
return selectedItem;
|
|
|
|
return store.getRootItems().get(0); //return root item
|
|
}
|
|
|
|
public boolean isSearch() {
|
|
return isSearch;
|
|
}
|
|
|
|
public void setSearch(boolean isSearch) {
|
|
System.out.println("***Set Search: " + isSearch);
|
|
this.isSearch = isSearch;
|
|
}
|
|
|
|
public void setSizeTreePanel(int width, int height){
|
|
treePanel.setSize(width, height);
|
|
}
|
|
|
|
|
|
public ContextMenuTree getContextMenuTree() {
|
|
return contextMenuTree;
|
|
}
|
|
|
|
public void setHeaderTreeVisible(boolean bool){
|
|
cp.setHeaderVisible(bool);
|
|
}
|
|
|
|
public FileModel getRootItem(){
|
|
return treePanel.getStore().getRootItems().get(0);
|
|
}
|
|
|
|
} |