// Copyright 2012 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.collide.client.workspace;
import com.google.collide.client.AppContext;
import com.google.collide.client.Resources;
import com.google.collide.client.code.FileSelectedPlace;
import com.google.collide.client.code.debugging.DebuggingModelController;
import com.google.collide.client.communication.ResourceUriUtils;
import com.google.collide.client.history.Place;
import com.google.collide.client.ui.tree.Tree;
import com.google.collide.client.ui.tree.TreeNodeElement;
import com.google.collide.client.ui.tree.TreeNodeLabelRenamer;
import com.google.collide.client.util.PathUtil;
import com.google.collide.client.workspace.FileTreeContextMenuController.ContextMenuMode;
import com.google.collide.json.shared.JsonArray;
import elemental.html.DragEvent;
import elemental.html.Location;
/**
* Listens for changes to the model via callbacks from {@link FileTreeModel} and updates the Tree.
* Similarly, this controller takes events reported from the {@link Tree} (like clicks and
* selections) and handles them.
*/
public class FileTreeUiController implements FileTreeModel.TreeModelChangeListener {
/**
* Static factory method for obtaining an instance of a FileTreeUiController.
*/
public static FileTreeUiController create(Place place,
FileTreeModel fileTreeModel,
Tree<FileTreeNode> tree,
AppContext appContext,
DebuggingModelController debuggingModelController) {
// Set the initial root node for the tree. This will simply be null on first
// load. But if it isn't we should probably still render what ever was in
// the FileTreeModel.
tree.getModel().setRoot(fileTreeModel.getWorkspaceRoot());
TreeNodeLabelRenamer<FileTreeNode> nodeLabelMutator = new TreeNodeLabelRenamer<FileTreeNode>(
tree.getModel().getNodeRenderer(), tree.getModel().getDataAdapter(),
appContext.getResources().workspaceNavigationFileTreeNodeRendererCss());
FileTreeUiController treeUiController = new FileTreeUiController(place,
appContext.getResources(),
fileTreeModel,
tree,
nodeLabelMutator,
appContext,
debuggingModelController);
fileTreeModel.addModelChangeListener(treeUiController);
treeUiController.attachEventHandlers();
return treeUiController;
}
/** Listener for drag-and-drop events on nodes in the file tree. */
public interface DragDropListener {
void onDragStart(FileTreeNode node, DragEvent event);
void onDragDrop(FileTreeNode node, DragEvent event);
}
private final FileTreeContextMenuController contextMenuController;
private DragDropListener uploadDragDropListener;
private DragDropListener treeNodeMoveListener;
private final FileTreeModel fileTreeModel;
private final Tree<FileTreeNode> tree;
private final Place currentPlace;
FileTreeUiController(Place place,
Resources res,
FileTreeModel fileTreeModel,
Tree<FileTreeNode> tree,
TreeNodeLabelRenamer<FileTreeNode> nodeLabelMutator,
AppContext appContext,
DebuggingModelController debuggingModelController) {
this.currentPlace = place;
this.fileTreeModel = fileTreeModel;
this.tree = tree;
this.contextMenuController = FileTreeContextMenuController.create(place,
res,
this,
fileTreeModel,
nodeLabelMutator,
appContext,
debuggingModelController);
}
/**
* Programmatically selects a node in the tree. This will cause any external handlers of the
* {@link Tree} to have their {@link com.google.collide.client.ui.tree.Tree.Listener#onNodeAction(TreeNodeElement)}
* method get invoked.
*/
public void autoExpandAndSelectNode(FileTreeNode nodeToSelect, boolean dispatchNodeAction) {
tree.autoExpandAndSelectNode(nodeToSelect, dispatchNodeAction);
}
public void expandNode(TreeNodeElement<FileTreeNode> parentTreeNode) {
tree.expandNode(parentTreeNode);
}
public void clearSelectedNodes() {
tree.getSelectionModel().clearSelections();
}
public FileTreeContextMenuController getContextMenuController() {
return contextMenuController;
}
public Tree<FileTreeNode> getTree() {
return tree;
}
public void setUploadDragDropListener(DragDropListener listener) {
uploadDragDropListener = listener;
}
public void setFileTreeNodeMoveListener(DragDropListener listener) {
treeNodeMoveListener = listener;
}
public void nodeWillBeAdded() {
}
/**
* Called when a node is added to the model. This will re-render the subtree rooted at this nodes
* parent iff the parent node is already rendered.
*/
@Override
public void onNodeAdded(PathUtil parentDirPath, FileTreeNode newNode) {
FileTreeNode rootNode = tree.getModel().getRoot();
if (rootNode == null) {
return;
}
if (PathUtil.WORKSPACE_ROOT.getPathString().equals(parentDirPath.getPathString())) {
// This means that we are adding to the base of the tree and should reRender.
reRenderSubTree(rootNode);
return;
}
FileTreeNode parentDir = rootNode.findChildNode(parentDirPath);
if (parentDir != null && parentDir.isComplete()) {
// Add the node.
TreeNodeElement<FileTreeNode> parentDirTreeNode = tree.getNode(parentDir);
if (parentDirTreeNode != null) {
reRenderSubTree(parentDir);
}
}
}
@Override
public void onNodeMoved(
PathUtil oldPath, FileTreeNode node, PathUtil newPath, FileTreeNode newNode) {
FileTreeNode rootNode = tree.getModel().getRoot();
if (rootNode == null) {
return;
}
if (node != null) {
FileTreeNode oldParent = rootNode.findChildNode(PathUtil.createExcludingLastN(oldPath, 1));
onNodeRemoved(oldParent, node.getRenderedTreeNode());
// do not kill the back reference (as in onNodeRemoved)!
}
if (newNode != null) {
PathUtil parentDirPath = PathUtil.createExcludingLastN(newPath, 1);
onNodeAdded(parentDirPath, newNode);
}
}
@Override
public void onNodesRemoved(JsonArray<FileTreeNode> oldNodes) {
FileTreeNode rootNode = tree.getModel().getRoot();
if (rootNode == null) {
return;
}
for (int i = 0; i < oldNodes.size(); i++) {
FileTreeNode oldNode = oldNodes.get(i);
// If we found a node at the specified path, then remove it.
if (oldNode != null) {
onNodeRemoved(oldNode.getParent(), oldNode.getRenderedTreeNode());
// Kill the back reference so we don't leak.
oldNode.setRenderedTreeNode(null);
}
}
}
@Override
public void onNodeReplaced(FileTreeNode oldNode, FileTreeNode newNode) {
if (!newNode.isDirectory()) {
// We don't need to do anything with files being replaced
return;
}
if (PathUtil.WORKSPACE_ROOT.getPathString().equals(newNode.getNodePath().getPathString())) {
// Install the workspace root for the tree and render it. Expansion state
// should be restored by this method.
tree.replaceSubtree(tree.getModel().getRoot(), newNode, false);
} else if (oldNode != null) {
TreeNodeElement<FileTreeNode> oldRenderedElement = oldNode.getRenderedTreeNode();
// If the node that we just replaced had a rendered tree node, we need
// to re-render.
if (oldRenderedElement != null) {
// If the node was loading, animate it open now that the children are available.
tree.replaceSubtree(oldNode, newNode, oldNode.isLoading());
// Kill the back reference so we don't leak.
oldNode.setRenderedTreeNode(null);
}
}
}
/**
* Re-renders the subtree rooted at the specified {@link FileTreeNode}, ensuring that its direct
* children are sorted.
*/
/* TODO : restore selection state */
public void reRenderSubTree(FileTreeNode parentDir) {
parentDir.invalidateUnifiedChildrenCache();
tree.replaceSubtree(parentDir, parentDir, false);
}
private void attachEventHandlers() {
tree.setTreeEventHandler(new Tree.Listener<FileTreeNode>() {
@Override
public void onNodeAction(TreeNodeElement<FileTreeNode> node) {
if (node.getData().isFile()
&& getContextMenuController().getMode() == ContextMenuMode.READY) {
currentPlace.fireChildPlaceNavigation(
FileSelectedPlace.PLACE.createNavigationEvent(node.getData().getNodePath()));
}
}
@Override
public void onNodeClosed(TreeNodeElement<FileTreeNode> node) {}
@Override
public void onNodeContextMenu(int mouseX, int mouseY, TreeNodeElement<FileTreeNode> node) {
getContextMenuController().show(mouseX, mouseY, node);
}
@Override
public void onNodeDragDrop(TreeNodeElement<FileTreeNode> node, DragEvent event) {
if (treeNodeMoveListener != null) {
treeNodeMoveListener.onDragDrop(node.getData(), event);
}
if (uploadDragDropListener != null) {
uploadDragDropListener.onDragDrop(node.getData(), event);
}
}
@Override
public void onRootDragDrop(DragEvent event) {
if (treeNodeMoveListener != null) {
treeNodeMoveListener.onDragDrop(fileTreeModel.getWorkspaceRoot(), event);
}
if (uploadDragDropListener != null) {
uploadDragDropListener.onDragDrop(fileTreeModel.getWorkspaceRoot(), event);
}
}
@Override
public void onNodeDragStart(TreeNodeElement<FileTreeNode> node, DragEvent event) {
// When drag starts in tree, we do not know if users want to drop it
// outside tree or in tree. So, we prepare for both cases.
prepareForDraggingToOutside(node, event);
if (treeNodeMoveListener != null) {
treeNodeMoveListener.onDragStart(node.getData(), event);
}
if (uploadDragDropListener != null) {
uploadDragDropListener.onDragStart(node.getData(), event);
}
}
@Override
public void onNodeExpanded(TreeNodeElement<FileTreeNode> node) {
if (!node.getData().isComplete() && !node.getData().isLoading()) {
// Mark the node as loading.
node.getData().setLoading(true);
tree.getModel().getNodeRenderer().updateNodeContents(node);
// Load the children of the directory.
fileTreeModel.requestDirectoryChildren(node.getData(), null);
}
}
@Override
public void onRootContextMenu(int mouseX, int mouseY) {
getContextMenuController().show(mouseX, mouseY, null);
}
private void prepareForDraggingToOutside(
TreeNodeElement<FileTreeNode> node, DragEvent event) {
FileTreeNode fileTreeNode = node.getData();
PathUtil nodePath = fileTreeNode.getNodePath();
String downloadFileName = fileTreeNode.isDirectory() ? nodePath.getBaseName() + ".zip"
: nodePath.getBaseName();
Location location = elemental.client.Browser.getWindow().getLocation();
String urlHttpHostPort = location.getProtocol() + "//" + location.getHost();
String downloadUrl = "application/octet-stream:" + downloadFileName + ":"
+ ResourceUriUtils.getAbsoluteResourceUri(nodePath)
+ (fileTreeNode.isDirectory() ? "?rt=zip" : "");
event.getDataTransfer().setData("DownloadURL", downloadUrl);
}
});
}
private void onNodeRemoved(FileTreeNode oldParent, TreeNodeElement<FileTreeNode> oldNode) {
tree.removeNode(oldNode);
// Make sure to remove expansion controls from any directory that might
// now be empty
if (oldParent != null && oldParent.getRenderedTreeNode() != null) {
if (oldParent.getUnifiedChildren().isEmpty()) {
oldParent.getRenderedTreeNode().makeLeafNode(tree.getResources().treeCss());
}
}
}
}