class dndList

var newItem = {label:"New Added Item",data:"10"};
theList.pasteItem(newItem, theList.selectedItem, theList.PASTE_AFTER, false, theList.METHOD_CALL, theList.ADD_BRANCH);

var newItem = {label:"New Added Item",data:"10"};
theList.pasteItem(newItem, theList.selectedItem, theList.PASTE_AFTER, false, theList.METHOD_CALL, theList.ADD_ITEM);

theList.addBranchPastePosition = theList.PASTE_AFTER;

// include delegation class
import mx.utils.Delegate;
// Add an addItem event function
function addItemEvent(evt) {
	trace("An item has been added to the list!");
	// reference to the list
	var theList = evt.target;
	// references to all the items involved 
	trace("The added item or parent item="+theList.selectedItem);
	trace("The target item="+theList.targetItem);
	trace("pastePosition="+evt.pastePosition);
	trace("thePasteToPosition="+theList.thePasteToPosition);
}
// we add a function that "listens" for the add event. When a addItem event is generated this function is called. 
theList.addEventListener("addItem", Delegate.create(this, addItemEvent));

theList.addItemPastePosition = theList.PASTE_BEFORE;

theList.canDropOnEmptyRows = true;

// include delegation class
import mx.utils.Delegate;
// Copy event function
function copyItemEvent(evt) {
	trace("A item has been copied from the list!");
	// reference to the list
	var theList = evt.target;
	// references to all the items involved 
	trace("Copied items="+theList.theCopyItems);
	trace("Copied items="+theList.selectedItems);
}
// we add a function that "listens" for the copy event. When a copyItem event is generated this function is called. 
theList.addEventListener("copyItem", Delegate.create(this, copyItemEvent));

// include delegation class
import mx.utils.Delegate;
// Cut event function
function cutItemEvent(evt) {
	trace("A item has been cut from the list!");
	// reference to the list
	var theList = evt.target;
	// references to all the items and components involved 
	trace("Cut items="+theList.theCopyItems);
	trace("The parent or sibling item="+theList.selectedItem);
}
// we add a function that "listens" for the cut event. When a cutItem event is generated this function is called. 
theList.addEventListener("cutItem", Delegate.create(this, cutItemEvent));

theList.dataProvider = [{label:"Item 1", data:10}, {label:"Item 2", data:20}, {label:"Item 3", data:30}];

theList.defaultBranchItem = {label:"New Item", data:"100"};

theList.defaultItem = {label:"New Item", data:"100"};

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

theList.dndEnabled = true;

theList.doNotInsertOnDrop = true;

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

theList.dragHighlightAlpha = 30;

trace(theList.dragOverPos);

trace(theList.DROP_EVENT);

theList.enabled = true;

theList.enableDragIcon = true;

theList.enableGenericIcon = true;

theList.enableKeySearch = true;

trace(theList.errorMsg);

theList.dataProvider = [{label:"Item 1"}, {label:"Item 2"}, {label:"Item 3"}];

movedItemIndex = theList.lastMovedIndex;

movedItemIndex = theList.lastMovedIndices[0];

movedItem = theList.lastMovedItem;

movedItemsLength = theList.lastMovedItems.length;

parentItem = theList.lastMovedParent;

parentItem = theList.lastMovedParents[0];

theItemSource = theList.lastMovedSource;

theItemSource = theList.lastMovedSources[0];

trace(theList.lastOver);

trace(theList.lastOverIndex);

trace(theList.MENU_EVENT);

trace(theList.METHOD_CALL);

theList.movementBeforeDrag = 8;

theList.multipleSelection = true;

// include delegation class
import mx.utils.Delegate;
// Drop Event
function itemDrop(evt) {
	// reference to the list
	var theList = evt.target;
	// references to all the items and components involved 
	trace("pastePosition="+evt.pastePosition);
	trace("targetItem="+evt.targetItem);
	trace("targetIndex="+evt.targetIndex);
	trace("thePasteToPosition="+theList.thePasteToPosition);
	trace("thePasteToParentItem="+theList.thePasteToParentItem);
	trace("lastMovedItem="+theList.lastMovedItem);
	trace("lastMovedIndex="+theList.lastMovedIndex);
	trace("lastMovedParent="+theList.lastMovedParent);
	trace("lastMovedSource="+theList.lastMovedSource);
	trace("lastMovedItems="+theList.lastMovedItems);
	trace("lastMovedIndices="+theList.lastMovedIndices);
	trace("lastMovedParents="+theList.lastMovedParents);
	trace("lastMovedSources="+theList.lastMovedSources);
	trace("targetItem="+theList.targetItem);
}
// we add a function that "listens" for the onDrop event. When an onDrop event is generated this function gets called. 
theList.addEventListener("onDrop", Delegate.create(this, itemDrop));

var newItem = {label:"New Added Item",data:"10"};
theList.pasteItem(newItem, theList.selectedItem, theList.PASTE_AFTER);

var newItem = {label:"New Added Item",data:"10"};
theList.pasteItem(newItem, theList.selectedItem, theList.PASTE_BEFORE);

var newItem = {label:"New Added Item",data:"10"};
theList.pasteItem(newItem, theList.selectedItem, theList.PASTE_INTO);

// include delegation class
import mx.utils.Delegate;
// Paste Item event function
function pasteItemEvent(evt) {
	// reference to the list
	var theList = evt.target;
	// references to all the items and components involved 
	trace("pastePosition="+evt.pastePosition);
	trace("thePasteToPosition="+theList.thePasteToPosition);
	trace("lastMovedItem="+theList.lastMovedItem);
	trace("lastMovedIndex="+theList.lastMovedIndex);
	trace("lastMovedSource="+theList.lastMovedSource);
	trace("lastMovedItems="+theList.lastMovedItems);
	trace("lastMovedIndices="+theList.lastMovedIndices);
	trace("lastMovedSources="+theList.lastMovedSources);
	trace("targetItem="+theList.targetItem);
}
// we add a function that "listens" for the paste event. When a pasteItem event is generated this function gets called. 
theList.addEventListener("pasteItem", Delegate.create(this, pasteItemEvent));

theList.cutItem(theList.selectedItem, theList.REMOVE_ITEM);

// include delegation class
import mx.utils.Delegate;
// Remove Event
function removeItem(evt) {
	// reference to the list
	var theList = evt.target;
	// references to all the items and components involved 
	trace("Removed items="+theList.theCopyItems);
}
// we add a function that "listens" for the remove event. When a removeItem event is generated this function gets called. 
theList.addEventListener("removeItem", Delegate.create(this, removeItem));

trace(theList.RENAME_ITEM);

theList.renameField = "theLabel";

theList.root_mc = _root;

theList.scrollDragSpeed = 100;

theList.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 list
	var theList = evt.target;
	// references to all the items and components involved 
	trace("absRowIndex="+evt.absRowIndex);
	trace("rowIndex="+evt.rowIndex);
	trace("this item has been clicked="+theList.selectedItem);
}
// we add a function that "listens" for the single click event. When a singleClick event is generated this function gets called. 
theList.addEventListener("singleClick", Delegate.create(this, singleClickEvent));

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

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

theList.dndCopyIcon = "myIcon";

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

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

theList.strNoDropIcon = "dndNoDropIcon2";

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

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

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

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

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

trace("Last item dropped on " + theList.targetItem.label);

trace(theList.theCopyItems.length);

theList.trackDebug = true;

theList.trashCan = trashCan_mc;

theList.visible = true;

// import the class
import com.judah.controls.dndList;
 
// create the list
createClassObject(dndList,"dndList",this.getNextHighestDepth());
 
// set the size and position
theList.setSize(240,250);
theList._x = 10;
theList._y = 70;
 
// fill the list with data
var arr:Array = new Array();
arr.push({label:"File 1",data:"file"});
arr.push({label:"File 1",data:"file"});
theList.dataProvider = arr;
 
// style the list
theList.setStyle("fontFamily", "_sans");
theList.setStyle("fontSize", 12);

// default code used in this function. cater to your needs
public function convertToGridItem(theItem) {
	//trace("\nconvertToGridItem()")
	// create new grid item from the list item
	var gridItem = new Object();
 
	// loop through and add any properties 
	// NOTE: This may copy references from the item
	for (var prop in theItem) {
		if (prop != "__ID__") {
			gridItem[prop] = theItem[prop];
		}
	}
	return gridItem;
}

// default code used in this function. cater to your needs
public function convertToNode(theItem) {
	//trace("convertToNode")
	// create new tree node from the list item properties
	var newXML = new XML('<node >');
	var newXMLNode = newXML.firstChild;
	
	// get label from item
	if (theItem.label!=undefined) {
		newXMLNode.attributes.label = label;
	}
	// get data from item
	if (theItem.data!=undefined) {
		newXMLNode.attributes.data = theItem.data;
	}
	// get icon if it exists
	if (getItemIcon(theItem)!=undefined) {
		newXMLNode.attributes.icon = getItemIcon(theItem);
	}
	
	// NOTE: This may copy references 
	for (var prop in theItem) {
		if (prop != "__ID__") {
			newXMLNode[prop] = theItem[prop];
		}
	}
	return newXMLNode;
}

var copyItem = theList.copyItem(theList.selectedItem);

theList.selectedIndices = [0,1,2]
var cutItem = theList.cutItem(theList.selectedItems);

// a lot of options are in the comments - you can uncomment to see what they do
function drawSeparator(objPoint, row, dragOverPos, bCanDrop) {
	//var maxWidth = 24;
	var maxWidth = _width/2;
	//var maxWidth = objPoint.x - 5;
	//trace("maxWidth="+maxWidth)
	
	if (dragOverPos == PASTE_BEFORE) {
		separator._visible = true;
		if (row.state!="normal") {
			//row.setState("normal", false);
		}
		separator._y = row._y;
	}
	else if (dragOverPos == PASTE_AFTER) {
		separator._visible = true;
		//row.icon_mc._alpha = 100;
		//row.setState("normal", false);
		//row.icon_mc.gotoAndStop(1);
		// this unhighlights the row
		if (row.state!="normal") {
			//row.setState("normal", false);
		}
		separator._y = row._y + rowHeight;
		//trace("_rowHeight="+rowHeight)
		//trace("rowHeight="+rowHeight)
	}
	else if(dragOverPos == PASTE_INTO) {
		//separator._visible = false;
		// row.icon_mc._alpha = 100;
		// this highlights the row
		if (row.state!="highlighted") {
			//row.setState("highlighted", false);
		}
		separator._y = row._y + (rowHeight/2);
		//separator._y = objPoint.y;
		//row.icon_mc.gotoAndStop(2);
		// hide separator if we cannot drop
		//if (bCanDrop) {
		//	trace("bCanDrop = true")
		//	separator._visible = false;
		//}
		//else {
		//	separator._visible = true;
		//}
		//
	}
	separator._alpha  = 100;
	separator._width  = maxWidth;
	separator._height = 1;
	separator.clear();
	separator.lineStyle(1, 0x666666, 50);
	separator.moveTo(0, 0);
	separator.lineTo(width,0);
	//separator._y = objPoint.y;
	// we can track the depth that we are at but it doesn't look that good.
	//separator._x = row.nodeIcon._x;
	separator._x = 5;
}

// define the getIsBranch function 
theList.getIsBranch = function(item) {
	// if the item has a property called isBranch and it is true
	if (item.isBranch) {
		// this is branch
		return true;
	}
	return false;
}

// define the getIsOpen function 
theList.getIsOpen = function(item) {
	// if the item has a property called isOpen
	//  we check it to tell the list that this item is open
	if (item.isOpen) {
		// this is open
		return true;
	}
	return false;
}

trace(theList.getItemIcon(theList.selectedItem));

trace(theList.getItemLabel(theList.selectedItem));

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

theList.permitContextMenu = function (theItem, theAction, theMenuItem, theContextMenu) {
	// "this" keyword does **NOT** reference the list here because we are in a different scope
	// use the list instance name directly
	
	// theList.PASTE_INTO is a static variable for paste into
	// if the action is to paste into then we allow it on branch items
	if (theAction==theList.PASTE_INTO) {
		// we are checking if the item we selected is a branch item
		// if true then we show the "paste into" menu item
		if (theList.getIsBranch(theItem)) {
			return true;
		}
		else {
			return false;
		}
	}
	return true;
}
 
// if we define this function we can use it to let the dndList drop INTO another row
// when a user is dragging over a row that is defined as a branch
theList.getIsBranch = function(item){
	var type = item.data;
	if (type=="folder") {
		return true;
	}
	return false;
}

// add items to the list
// we set the arbitrary fileType property for use in icon function
theList.addItem({label:".. ",data:"green",icon:"folder",fileType:"parentFolder"});
theList.addItem({label:"Folder 1",data:"red",icon:"folder",fileType:"folder"});
theList.addItem({label:"Folder 2",data:"red",icon:"folder",fileType:"folder"});
theList.addItem({label:"File 1",data:"blue",icon:"file",fileType:"file"});
theList.addItem({label:"File 2",data:"blue",icon:"file",fileType:"file"});
theList.addItem({label:"File 3",data:"blue",icon:"file",fileType:"file"});
 
// the permit drop function is used when dragging and dropping
theList.permitDropFunction = function (theSourceItem, theTargetItem, theAction) {
	// we are in a different scope. the keyword "this" references the dndList
	//trace("theSourceItem ="+theSourceItem.label);
	//trace("theTargetItem ="+theTargetItem.label);
	
	// we are checking if the item we are dragging over is a branch item
	// we have to define the getIsBranch method to enable dropping into an item.
	// if true then we can paste into it. if not then no pasty
	// we return false to prevent a drop from occuring
	// returning false also shows the "no drop" allowed icon
	if (this.getIsBranch(theTargetItem)) {
		// this.PASTE_INTO is a static variable for paste into
		// if the action is to paste into then we allow it
		if (theAction==this.PASTE_INTO) {
			return true;
		}
	}
	// if we are not dragging into the branch we do not allow it
	return false;
}
 
// define the getIsBranch function 
theList.getIsBranch = function(item) {
	// if the item has a property called isBranch and it is true
	if (item.fileType=="folder") {
		// this is branch
		return true;
	}
	return false;
}

// import the alert contol - add to the library
import mx.controls.Alert;
 
// prompt user on remove event
theList.permitRemove = function (theDataGrid, menuItem, menuCaption, eventType) {
	// BE CAREFUL of SCOPE ISSUES HERE
	var itemLabel = theList.selectedItem.label;
	var eventName = "cut";
	var output = "";
	// check if this is a remove event
	if (eventType == theList.REMOVE_ITEM) {
		eventName = "remove";
	}
	
	myClickHandler = function (evt) {
		if (evt.detail == Alert.OK) {
			theList.cutItem(theList.selectedItems, theList.MENU_EVENT, eventType);
		}
	}
	output = "Are you sure you want to " + eventName + " " + itemLabel + "?";
	var myAlert = Alert.show(output, "Confirm File Delete", Alert.OK | Alert.CANCEL, this, myClickHandler, "stockIcon", Alert.OK);
	return false;
}

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

public function setItemLabel (theItem:Object, labelText:String, originalText:String):String {
	var retVal;
	//NOTE: User may need to redefine this function if they define the labelFunction
	// if an label field exists then set the text to that
	if (labelField != undefined) {
		theItem[labelField] = labelText;
		retVal = labelText;
	}
	else {
		// labelField is not set use default label property
		theItem.label = labelText;
		retVal = labelText;
	}
	
	return retVal;
}

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;
}

// this lets the user enter anything besides blank text
theList.validateItemLabel = function(newText, renameTextField) {
	// check if new text user entered is blank
	if (newText=="") {
		// 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;
	}
}