class dndTree

theTree.pasteNode(sourceNode, targetNode, theTree.PASTE_AFTER, moveNode, theTree.METHOD_CALL, theTree.ADD_BRANCH);

theTree.pasteNode(sourceNode, targetNode, theTree.PASTE_AFTER, moveNode, theTree.METHOD_CALL, theTree.ADD_LEAF);

// include delegation class
import mx.utils.Delegate;
// Add Branch Node event function
function addBranchNodeEvent(evt) {
trace("A branch node has been added to the tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes involved 
trace("The added branch node ="+theTree.selectedNode);
trace("The target node="+theTree.targetNode);
trace("pastePosition="+evt.pastePosition);
trace("thePasteToPosition="+theTree.thePasteToPosition);
trace("thePasteToParentNode="+theTree.thePasteToParentNode);
}
// we add a function that "listens" for the add event. When an addBranchNode event is generated this function is called. 
theTree.addEventListener("addBranchNode", Delegate.create(this, addBranchNodeEvent));

theTree.addBranchPastePosition = theTree.PASTE_AFTER;

// include delegation class
import mx.utils.Delegate;
// Add Leaf Node event function
function addLeafNodeEvent(evt) {
trace("A leaf node has been added to the tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes involved 
trace("The added leaf node or parent node="+theTree.selectedNode);
trace("The target node="+theTree.targetNode);
trace("pastePosition="+evt.pastePosition);
trace("thePasteToPosition="+theTree.thePasteToPosition);
trace("thePasteToParentNode="+theTree.thePasteToParentNode);
}
// we add a function that "listens" for the add event. When a addLeafNode event is generated this function is called. 
theTree.addEventListener("addLeafNode", Delegate.create(this, addLeafNodeEvent));

theTree.addLeafPastePosition = theTree.PASTE_AFTER;

theTree.branchNodeXML = "<node label='my node'></node>";
theTree.addBranchNode(theTree.selectedNode, theTree.PASTE_INTO);

theTree.canDropOnEmptyRows = true;

theTree.clickThreshold = 400;

// include delegation class
import mx.utils.Delegate;
// Copy event function
function copyNodeEvent(evt) {
trace("A node has been copied from the tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes involved 
trace("Copied nodes="+theTree.theCopyNodes);
trace("Copied nodes="+theTree.selectedNodes);
}
// we add a function that "listens" for the copy event. When a copyNode event is generated this function is called. 
theTree.addEventListener("copyNode", Delegate.create(this, copyNodeEvent));

// include delegation class
import mx.utils.Delegate;
// Cut event function
function cutNodeEvent(evt) {
trace("A node has been cut from the tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("Cut nodes="+theTree.theCopyNodes);
trace("The parent or sibling node="+theTree.selectedNode);
}
// we add a function that "listens" for the cut event. When a cutNode event is generated this function is called. 
theTree.addEventListener("cutNode", Delegate.create(this, cutNodeEvent));

// include delegation class
import mx.utils.Delegate;
// Delayed click event function
function delayedClickEvent(evt) {
trace("A row has been delay clicked!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("absRowIndex="+evt.absRowIndex);
trace("rowIndex="+evt.rowIndex);
trace("delayedclicked node="+theTree.selectedNode);
}
// we add a function that "listens" for the delayed click event. When a delayedClick event is generated this function gets called. 
theTree.addEventListener("delayedClick", Delegate.create(this, delayedClickEvent));

theTree.dndEnabled = true;

theTree.dndGutter = 5;

theTree.dndReadOnly = true;

theTree.doNotInsertOnDrop = true;
 
function droppedOnto(evt) {
	trace("dropped onto="+evt.targetNode);
	trace("dropped ="+evt.nodes);
}
theTree.addEventListener("onDrop",droppedOnto);
 

// include delegation class
import mx.utils.Delegate;
// Double click event function
function doubleClickEvent(evt) {
trace("A row has been double clicked!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("absRowIndex="+evt.absRowIndex);
trace("rowIndex="+evt.rowIndex);
trace("doubleclicked node="+theTree.selectedNode);
}
// we add a function that "listens" for the double click event. When a doubleClick event is generated this function gets called. 
theTree.addEventListener("doubleClick", Delegate.create(this, doubleClickEvent));

theTree.dragHighlightAlpha = 30;

trace(theTree.dragOverPos);

// include delegation class
import mx.utils.Delegate;
// Drop Event
function nodeDrop(evt) {
trace("A node has been dropped onto the Tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("pastePosition="+evt.pastePosition);
trace("thePasteToPosition="+theTree.thePasteToPosition);
trace("thePasteToParentNode="+theTree.thePasteToParentNode);
trace("lastMovedItem="+theTree.lastMovedItem);
trace("lastMovedIndex="+theTree.lastMovedIndex);
trace("lastMovedParent="+theTree.lastMovedParent);
trace("lastMovedSource="+theTree.lastMovedSource);
trace("lastMovedItems="+theTree.lastMovedItems);
trace("lastMovedIndices="+theTree.lastMovedIndices);
trace("lastMovedParents="+theTree.lastMovedParents);
trace("lastMovedSources="+theTree.lastMovedSources);
trace("targetNode="+theTree.targetNode);
trace("targetNode="+theTree.selectedNode);
trace("targetNode="+theTree.selectedNodes);
trace("targetNode="+theTree.selectedNode.firstChild);
}
// we add a function that "listens" for the drop event. When a drop event is generated this function gets called. 
theTree.addEventListener("onDrop", Delegate.create(this, nodeDrop));

trace(theTree.DROP_EVENT);

theTree.enabled = true;

myInstance.enableKeySearch = false;

trace(theTree.errorMsg);

movedNodeIndex = theTree.lastMovedIndex;

movedNodeIndex = theTree.lastMovedIndices[0];

movedNode = theTree.lastMovedItem;

movedNode = theTree.lastMovedItems.length;

parentNode = theTree.lastMovedParent;

parentNode = theTree.lastMovedParents[0];

theNodeSource = theTree.lastMovedSource;

theNodeSource = theTree.lastMovedSources[0];

trace(theTree.lastOver);

trace(theTree.lastOverIndex);

theNodeSource = theTree.lastSelectedSources[0];

theTree.leafNodeXML = "<node label='my node'/>";
theTree.addLeafNode(theTree.selectedNode, theTree.PASTE_AFTER);

trace(theTree.MENU_EVENT);

trace(theTree.METHOD_CALL);

theTree.multipleSelection = true;

The example below adds a listener to the nodeOpen event.

// include delegation class
import mx.utils.Delegate;
// Node Open event function
function nodeOpenEvent(evt) {
trace("A branch node has been opened!");
// reference to the tree
var theTree = evt.target;
// reference to the node opened
trace("The opened node="+evt.target.node);
}
// we add a function that "listens" for the node open event. When a nodeOpen event is generated this function is called. 
theTree.addEventListener("nodeOpen", Delegate.create(this, nodeOpenEvent));

The example below adds a listener to the nodeOpen event.

// include delegation class
import mx.utils.Delegate;
// Node Close event function
function nodeCloseEvent(evt) {
trace("A branch node has been closed!");
// reference to the tree
var theTree = evt.target;
// reference to the node closed
trace("The closed node="+evt.target.node);
}
// we add a function that "listens" for the node close event. When a nodeClose event is generated this function is called. 
theTree.addEventListener("nodeClose", Delegate.create(this, nodeCloseEvent));

theTree.openClosedBranchOnPasteInto = true;

// first example
theTree.addLeafNode(targetNode, theTree.PASTE_AFTER, sourceNode);
// second example
theTree.pasteNode(sourceNode, targetNode, theTree.PASTE_AFTER, moveNode);

theTree.addLeafNode(targetNode, theTree.PASTE_BEFORE, sourceNode);

theTree.addLeafNode(targetNode, theTree.PASTE_INTO, sourceNode);

// include delegation class
import mx.utils.Delegate;
// Paste Node event function
function pasteNodeEvent(evt) {
trace("A node has been pasted into the Tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("pastePosition="+evt.pastePosition);
trace("thePasteToPosition="+theTree.thePasteToPosition);
trace("thePasteToParentNode="+theTree.thePasteToParentNode);
trace("lastMovedItem="+theTree.lastMovedItem);
trace("lastMovedIndex="+theTree.lastMovedIndex);
trace("lastMovedParent="+theTree.lastMovedParent);
trace("lastMovedSource="+theTree.lastMovedSource);
trace("lastMovedItems="+theTree.lastMovedItems);
trace("lastMovedIndices="+theTree.lastMovedIndices);
trace("lastMovedParents="+theTree.lastMovedParents);
trace("lastMovedSources="+theTree.lastMovedSources);
trace("targetNode="+theTree.targetNode);
trace("targetNode="+theTree.selectedNode);
trace("targetNode="+theTree.selectedNodes);
trace("targetNode="+theTree.selectedNode.firstChild);
}
// we add a function that "listens" for the paste event. When a pasteNode event is generated this function gets called. 
theTree.addEventListener("pasteNode", Delegate.create(this, pasteNodeEvent));

theTree.cutNode(sourceNode, theTree.REMOVE_ITEM);

// include delegation class
import mx.utils.Delegate;
// Remove Event
function removeNode(evt) {
trace("A node has been removed from the Tree!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("Removed nodes="+theTree.theCopyNodes);
trace("The parent or sibling node="+theTree.selectedNode);
}
// we add a function that "listens" for the remove event. When a removeNode event is generated this function gets called. 
theTree.addEventListener("removeNode", Delegate.create(this, removeNode));

trace(theTree.RENAME_ITEM);

theTree.renameField = "theLabel";

theTree.root_mc = _root;

theTree.scrollDragSpeed = 200;

theTree.showDebug = true;

// include delegation class
import mx.utils.Delegate;
// Double click event function
function singleClickEvent(evt) {
trace("A row has been single clicked!");
// reference to the tree
var theTree = evt.target;
// references to all the nodes and components involved 
trace("absRowIndex="+evt.absRowIndex);
trace("rowIndex="+evt.rowIndex);
trace("selectedIndex="+theTree.selectedIndex);
trace("this node has been clicked="+theTree.selectedNode);
}
// we add a function that "listens" for the single click event. When a singleClick event is generated this function gets called. 
theTree.addEventListener("singleClick", Delegate.create(this, singleClickEvent));

theTree.cm.customItems[0].caption = "new text".
theTree.menu.customItems[0].caption = "new text".

theTree.menu.customItems[0].caption = "new text"

theTree.dndCopyIcon = "myIconId";

theTree.menu.customItems[0].caption = "new text"

theTree.menu.customItems[0].caption = "new text";

theTree.strDragBranchIcon = "myIconId";

theTree.strDragBranchOpenedIcon = "myIconId";

theTree.strDragLeafIcon = "myIconId";

theTree.strNoDropIcon = "myIconId";

theTree.menu.customItems[0].caption = "new text"

theTree.menu.customItems[0].caption = "new text"

theTree.menu.customItems[0].caption = "new text"

theTree.menu.customItems[0].caption = "new text"

theTree.cm.customItems[0].caption = "new text".
theTree.menu.customItems[0].caption = "new text".

trace(theTree.targetNode);

trace(theTree.theCopyGridItems);

trace(theTree.theCopyNodes);

theTree.trackDebug = true;

theTree.visible = true;

// note: be sure to add the tree to the library
import com.judah.controls.dndTree;
createClassObject(dndTree,"theTree",5);
 
theTree.setSize(180,190);
theTree._x = 25;
theTree._y = 25;
 
theTree.dataProvider = new XML("<node label='root'><node label='child'/><node label='child 2'/></node>");
var rootNode = theTree.getTreeNodeAt(0);
var newChild = rootNode.addTreeNode("new child");
theTree.setIsOpen(rootNode, true);
theTree.selectedNode = newChild;
theTree.setStyle("selectionColor", 0x006699);
theTree.setStyle("rollOverColor", 0xBECAD6);
theTree.setStyle("textRollOverColor", 0x2B333C);
theTree.setStyle("textSelectedColor", 0xFDFDFD);

var newBranchNode = theTree.addBranchNode(theTree.selectedNode, theTree.PASTE_AFTER);
trace("newNode = "+newBranchNode);

theTree.addLeafNode(theTree.selectedNode, theTree.PASTE_AFTER);

theTree.cancelRename()

public function convertToGridItem(theNode) {
	// create new grid row from xml node
	var gridItem = new Object();
	// NOTE: This may copy references from the node. 
 
	// loop through and add any attributes
	for (var prop in theNode.attributes) {
		gridItem[prop] = theNode.attributes[prop];
	}
	
	// loop through and add any properties 
	for (var prop in theNode) {
		gridItem[prop] = theNode[prop];
	}
	
	return gridItem;
}

public function convertToItem(theNode) {
	// create new item from xml node
	var newItem = new Object();
	
	// loop through and add any attributes
	for (var prop in theNode.attributes) {
		newItem[prop] = theNode.attributes[prop];
	}
	
	// loop through and add any properties 
	for (var prop in theNode) {
		newItem[prop] = theNode[prop];
	}
	
	return newItem;
}

theTree.copyNode(theTree.selectedNode);

theTree.cutNode(theTree.selectedNode);

theTree.getIsLeaf(node);

trace(theTree.nodeIcon(node));

trace(theTree.getNodeLabel(node));

theTree.onContextMenuSelect = function () {
	var customItems = theTree.cm.customItems;
	customItems[0].visible = false;
}

theTree.pasteNode(theTree.selectedNode, theTree.dataProvider, theTree.PASTE_INTO, true);

theTree.permitContextMenu = function (theSourceNode, theAction, theMenuItem, theContextMenu) {
	// trace("the node being examined is " + theSourceNode.attributes.label)
	// trace("   the menu item being passed in is="+ theMenuItem.caption)
	// prevent a user from pasting into a leaf node if preventDropIntoLeafNodes is set to true
	if (theTree.getIsLeaf(theSourceNode) && preventDropIntoLeafNodes && theAction==theTree.PASTE_INTO) {
		return false;
	}
	return true;
}

theTree.permitDropFunction = function (theSourceNode, theTargetNode, theAction) {
	if (theTree.getIsLeaf(theSourceNode)) {
		if (theAction==theTree.PASTE_INTO) {
			return false;
		}
	}
	return true;
}

// The code below is the default code
function renameFunction (rowIndex, eventSource) {
	// show the rename textfield
	showRenameNode(rowIndex, eventSource);
}

theTree.setNodeLabel(theTree.selectedNode, labelText)

// setNodeLabel function defined
public function setNodeLabel (theNode:XMLNode, labelText:String):String {
	var nodeLabel:String;
	
	// if a label function exists then set the text to display
	if (labelField != undefined) {
		// if an label field exists then set the label for that
		theNode.attributes[labelField] = labelText;
		nodeLabel = labelText;
	}
	else {
		// labelField is not set
		theNode.attributes.label = labelText;
		nodeLabel = labelText;
	}
	return nodeLabel;
}

function toolTipFunction(row_mc) {
	// determine if we are using a cell renderer by checking if cell has the renameField or a textfield we know exists in our cellrenderer
	var bCellRenderer:Boolean = (row_mc.cll.renameField != undefined) ?  true : false;
	// get a reference to the row label - you may need to point this to your textfield
	var rowLabel = (bCellRenderer) ? row_mc.cll.renameField : row_mc.cll;
	// set selectable to false to prevent text cursor 
	rowLabel.selectable = false;
	// set border color, border and background
	rowLabel.setStyle("borderColor",0xD5DDDD);
	rowLabel.border = true;
	rowLabel.background = true;
	// some properties i've turned off but could be enabled
	//rowLabel.autoSize = "left";
	//rowLabel.wordWrap = true;
	//rowLabel.multiline = true;
	// autosize text field
	rowLabel.autoSize = "center";
	// snap cell (label) to the left edge of the row which is positioned next to the mouse
	row_mc.cell._x = 0;
}

theTree.validateNodeLabel = function(newText, renameTextField) {
	// check if new text user entered is blank. this is the default code of this function
	if (newText=="") {
		trace("label is blank!!! ahhh run away!!!");
		// restore original text
		renameTextField.text = renameTextField.orgText;
		// reselect text and cancel commit
		Selection.setSelection(0, renameTextField.length);
		return false;
	}
	else {
		// new text is not blank. allow rename
		return true;
	}
}