<?xml version="1.0" encoding="utf-8"?>
<!-- TreeExplorer is a HDividedBox that contains a Tree and two Navigators. The selectedItem attribute 
	of the Tree is bound to the selectedItem attributes of the Navigators. One Navigator (propsNavigator)
	is supposed to contain a Form to edit and view the selectedItem and another (buttonBar) should 
	contain Button controls to initiate actions associated with the selectedItem. --> 
<mx:HDividedBox xmlns:mx="http://www.adobe.com/2006/mxml"
	xmlns:components="components.*" xmlns:propsNavigator="components.propsNavigator.*"
	xmlns:tree="components.tree.*">
	
	<mx:Script>
		<![CDATA[
			import events.ItemMovedEvent;
			import mx.events.FlexEvent;
			import mx.controls.listClasses.IListItemRenderer;
			import mx.controls.List;
			import components.tree.NodeTest;
			import components.tree.DragAndDropRule;
			import components.tree.LabelRule;
			import components.tree.IconRule;
			import mx.controls.treeClasses.ITreeDataDescriptor;
			import mx.core.Container;
			import mx.binding.utils.ChangeWatcher;
			import mx.events.DragEvent;
			import mx.collections.XMLListCollection;
			import mx.managers.DragManager;
			import mx.core.UIComponent;
			import mx.controls.treeClasses.TreeItemRenderer;
			
			// Properties navigator parameters	
			[Bindable]
			public var defaultForm:Container;
			
			[Bindable]
			private var _forms:Array;
			
			// Tree parameters
			[Bindable]
			public var tree:Object;
			
			[Bindable]
			public var initialExpand:int = 0;
			
			[Bindable]
			/**
			 * An Array that defines which elements are supposed to the treated as branches. If an object
			 * is of type NodeTest the method doTest is called. Otherwise the object is compared (==) to 
			 * the result of the name() method of the XML object. 
			 */
			public var branches:Array;					
			
			[Bindable]
			/**
			 * May contain LabelRule objects that define how XML objects are labeled in the tree.  
			 */
			public var labelRules:Array;
			
			[Bindable]
			/**
			 * May contain IconRule objects that define what icon has to be used in the tree.  
			 */
			public var iconRules:Array;
			
			[Bindable]
			/**
			 * Rules that define which elements are allowed to be dragged and where those elements 
			 * are allowed to drop.
			 */
			public var dragAndDropRules:Array;
			
			[Bindable]
			public var treeItemRenderer:Class = TreeItemRenderer;
			
			// ButtonBar components
			[Bindable]
			public var buttonBars:Array;
			
			/**
			 * Determines the label of a XML object.
			 */
			private function treeLabel(node:XML) : String {
				// Looks for a matching labelRule
				if(labelRules != null) {
					for each(var rule:Object in labelRules) {
						if(rule is LabelRule) {
							var label:String = LabelRule(rule).getLabel(node);
							if(label != null) {
								return label;
							}							
						}
					}
				}
				
				// If XML object is an element (appearently without a label rule)
				if(node.nodeKind() == "element") {					 					
					return node.localName();
				} else { // Otherwise a text node
					return node.toString();
				}
			}
			
			public function set forms(containers:Array) : void {
				_forms = containers;
			}
			
			[Bindable]
			[Embed("assets/folder.png")]
			protected var folderIcon:Class;
			
			[Bindable]
			[Embed("assets/page.png")]
			protected var pageIcon:Class;
			
			[Bindable]
            [Embed("assets/folder_page_white.png")]
            protected var openBranchIcon:Class;	
            
            [Bindable]
            [Embed("assets/folder_table.png")]
            protected var configOpenBranchIcon:Class;
			
			/**
			 * Determines the icon of a XML object.
			 */
			private function treeIcon(node:XML) : Class {
				// Looks for a matching labelRule
				if(iconRules != null) {
					for each(var rule:Object in iconRules) {
						if(rule is IconRule) {
							var icon:Class = IconRule(rule).getIcon(node, myTree);
							if(icon != null) {
								return icon;
							}	
						}
					}
				}
				
				if(myTree.dataDescriptor.isBranch(node)) {
					return folderIcon;
				} else {
					return pageIcon;	
				}
			}
			
			/**
			 * Event handler. Called when dragging is started.
			 */
			private function dragStart(event:DragEvent) : void
	        {
	        	event.ctrlKey = false;
	        	event.action = DragManager.MOVE;
	        	
	        	// The item to be dragged
	        	var item:XML = XML(myTree.selectedItem);
	        	
	        	// Workaround: internal tree representation is sometimes messed up at this point. Forcing 
	        	// the tree to rebuild part of its internal data.
	        	var parent:XML = item.parent();
	        	if(parent) {
	        		myTree.expandItem(parent, false);
	        		myTree.expandItem(parent, true);
	        	}
	        	
	        	//Root nodes cannot be moved 
	        	if(item.parent() != null) { 	        	
		        	// Every allowed drag and drop action has to be explicitly configured
		        	if(dragAndDropRules != null) {
		        		for each(var obj:Object in dragAndDropRules) {
		        			if(obj is DragAndDropRule) {
		        				var rule:DragAndDropRule = DragAndDropRule(obj);
		        					        				
		        				if(rule.child is NodeTest) {
		        					if(NodeTest(rule.child).doTest(item)) {
		        						return;
		        					}
		        				} else {
		        					if(item.name() == rule.child) {
		        						return;
		        					}
		        				}
		        			}
		        		}
		        	}
	        	}
	        	
	        	// Prohibit drag action if no rule matches
	        	event.preventDefault();
	        }
	        
	        protected var dragItem:XML
	        protected var dropParentItem:XML;
	        
	        /**
	        * Helper function to determine if a particular drop action is allowed.
	        */
	        protected function isDropAllowed(event:DragEvent) : Boolean {
	        	// Every allowed drag and drop action has to be explicitly configured
	        	if(!dragAndDropRules) {
	        		return false;
	        	}
	        	
	        	var index:Number = myTree.selectedIndex;
	        	dragItem = XML(myTree.selectedItem);
	        	
	        	var dropIndex:Number = myTree.calculateDropIndex(event);
	        	var itemRenderer:IListItemRenderer = myTree.indexToItemRenderer(dropIndex);
	        	
	        	// Bottom of tree? 
	        	var overflow:Boolean = false;
	        	while(itemRenderer == null) {	        	
	        		dropIndex--;
	        		itemRenderer = myTree.indexToItemRenderer(dropIndex);
	        		overflow = true;
	        	}
	        		        	
	        	dropParentItem = null;
	        	var dropItem:XML = 	XML(itemRenderer.data);
	        	
	        	// Location of drop event
	        	var point:Point = myTree.globalToLocal(new Point(event.stageX, event.stageY));
	        	var offset:Number = point.y - UIComponent(itemRenderer).y;
		        var height:Number = UIComponent(itemRenderer).height;
	        	
	        	// Bottom of tree
	        	if(overflow) {
	        		dropParentItem = dropItem.parent();
	        		
	        		// Multiple root nodes are not allowed
	        		if(offset > height * 1.5 || dropParentItem == null) {
	        			return false;
	        		}
	        	} else {
	        		// Current drop target is an empty opened branch		        	
		        	if(myTree.dataDescriptor.isBranch(dropItem)) {
		        		if(myTree.isItemOpen(dropItem) && !myTree.dataDescriptor.hasChildren(dropItem)
		        			&& offset > height * 0.5) {
		        			dropParentItem = dropItem;
		        		} else {
				        	if(dropIndex > 0 && offset < height * 0.5) {
			        			itemRenderer = myTree.indexToItemRenderer(dropIndex - 1);
			        			dropItem = XML(itemRenderer.data);
			        		}
			        	}		        			        		
		        	}
	        	}
	        	
	        	if(dropItem != null || dropParentItem != null) {
	        		// No parentItem is found yet. Use the parent of the dropItem (default case).
	        		if(dropParentItem == null) {      	 	        	 	        	
	        			dropParentItem = dropItem.parent();
	        		}
	        	
	        		// Multiple root nodes are not allowed
		        	if(dropParentItem != null) {
		        		for each(var obj:Object in dragAndDropRules) {
		        			if(obj is DragAndDropRule) {
		        				var rule:DragAndDropRule = DragAndDropRule(obj);
		        				
		        				if(rule.child is NodeTest && NodeTest(rule.child).doTest(dragItem)
		        					|| !(rule.child is NodeTest) && rule.child == dragItem.name()) {
		        					for each(var parentObj:Object in rule.parents) {
		        						if(parentObj is NodeTest) {
		        							if(NodeTest(parentObj).doTest(dropParentItem)) {
		        								return true;
		        							}	        							
		        						} else {
		        							if(parentObj == dropParentItem.name()) {
		        								return true;
		        							}
		        						}
		        					}
		        				} 
		        			}
		        		}
		        	}		        	
		        }
	        	
	        	return false;
	        }
	        
	        /**
	         * Event handler. Called after dragging is started.
	         */	         
	        private function dragEnter(event:DragEvent) : void {
	        	event.ctrlKey = false;
	        	event.action = DragManager.MOVE;
	        }
			
			/**
			 * Event handler. Called when the mouse is moved while dragging.
			 */
			private function dragOver(event:DragEvent) : void
	        {
	        	if(!isDropAllowed(event)) {
		        	event.preventDefault();
		        	myTree.hideDropFeedback(event);
	        	}
	        	
	        	event.ctrlKey = false;
	        	event.action = DragManager.MOVE;
	        }
	        
	        /**
	        * Event handler. Called when an item is dropped.
	        */
	        private function dragDrop(event:DragEvent) : void
	        {
	        	if(!isDropAllowed(event)) {
		        	event.preventDefault();
		        	myTree.hideDropFeedback(event);
	        	}
	        	
	        	callLater(dispatchEvent, [new ItemMovedEvent(dragItem, dragItem.parent(), dropParentItem)]);
	        	
	        	event.action = DragManager.MOVE;
	        }
		]]>
	</mx:Script>
	
	<mx:Metadata>
   		[Event(name="itemMoved", type="events.ItemMovedEvent")]
   	</mx:Metadata>
	
	<components:ExtendedBox height="100%" direction="vertical" enforceMeasuredMinWidth="true">
		<components:ExtendedTree id="myTree" width="100%" height="100%" horizontalScrollPolicy="on"	
			dataProvider="{tree}"		
			initialExpand="{initialExpand}"
			labelFunction="{treeLabel}"
			iconFunction="{treeIcon}"
			dragEnabled="true"
			dropEnabled="true"
			itemRenderer="{new ClassFactory(treeItemRenderer)}"
			dragOver="{dragOver(event)}"
			dragEnter="{dragEnter(event)}"
			dragStart="{dragStart(event)}"
			dragDrop="{dragDrop(event)}">
			<components:dataDescriptor>
				<tree:GenericDataDescriptor branches="{branches}"/>
			</components:dataDescriptor>
		</components:ExtendedTree>
		<components:Navigator selectedItem="{XML(myTree.selectedItem)}" minWidth="200"
				containers="{buttonBars}" width="100%">
			<components:defaultContainer><mx:Container/></components:defaultContainer>
		</components:Navigator>
	</components:ExtendedBox>
	<components:Navigator id="propsNav" invalid="{myTree.selectable = false}" 
		valid="myTree.selectable = true" 
		defaultContainer="{defaultForm}"
		containers="{_forms}"
		width="100%" height="100%" selectedItem="{XML(myTree.selectedItem)}"/>
</mx:HDividedBox>