<?xml version="1.0" encoding="utf-8"?> 
<!--

  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You 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.

-->
<s:Application
			   xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx"
			   xmlns:local="*" xmlns:comps="components.*"
			   width="800" height="800">
	<fx:Style>
		@namespace s "library://ns.adobe.com/flex/spark";
		@namespace mx "library://ns.adobe.com/flex/mx";

		@font-face {
			src: url("../../../../../Assets/Fonts/Open_Sans/OpenSans-Regular.ttf");
			fontFamily: MyVera;			
			embedAsCFF: true;
		}

		@font-face {
			src: url("../../../../../Assets/Fonts/Open_Sans/OpenSans-Italic.ttf");
			fontFamily: MyVera;
			fontStyle: italic;
			embedAsCFF: true;
		}

		@font-face {
			src: url("../../../../../Assets/Fonts/Open_Sans/OpenSans-Bold.ttf");
			fontFamily: MyVera;
			fontWeight: bold;
			embedAsCFF: true;
		}
		@font-face {
			src: url("../../../../../Assets/Fonts/Open_Sans/OpenSans-Regular.ttf");
			fontFamily: MyVeraHalo;
			embedAsCFF: false;
		}

		@font-face {
			src: url("../../../../../Assets/Fonts/Open_Sans/OpenSans-Italic.ttf");
			fontFamily: MyVeraHalo;
			fontStyle: italic;
			embedAsCFF: false;
		}

		@font-face {
			src: url("../../../../../Assets/Fonts/Open_Sans/OpenSans-Bold.ttf");
			fontFamily: MyVeraHalo;		
			fontWeight: bold;
			embedAsCFF: false;
		}				

        mx|ColorPicker {
		    fontFamily: MyVeraHalo;
		    fontAntiAliasType: normal;
			fontLookup: "embeddedCFF";		
        }
        
		s|DataGrid s|GridColumnHeaderGroup {
			fontAntiAliasType: "normal";
			fontFamily: MyVera;
			fontLookup: "embeddedCFF";		
		}

		global{
		    fontFamily: MyVera;
		    fontAntiAliasType: normal;
		    kerning: "off";
        }
	 		
	</fx:Style>
	
	<fx:Declarations>
		  
		
		<s:ArrayList id="column1">
			<s:GridColumn dataField="index" />
			<s:GridColumn dataField="firstName" />
			<s:GridColumn dataField="lastName" />
		</s:ArrayList>
			<s:ArrayList id="column2">
				<s:GridColumn dataField="index" />
				<s:GridColumn dataField="firstName" />
				<s:GridColumn dataField="lastName" />
				<s:GridColumn dataField="unmatch field" />
			</s:ArrayList>
			<s:ArrayList id="column3">
				
			</s:ArrayList>
		<s:ArrayList id="column4">
			<s:GridColumn dataField="index"  />
			<s:GridColumn dataField="firstName" />
			<s:GridColumn dataField="lastName" />
			<s:GridColumn dataField="food" />
			<s:GridColumn dataField="drink"/>
		</s:ArrayList>
		<s:ArrayList id="column5">
			<s:GridColumn dataField="@index" width="30"/>
			<s:GridColumn dataField="@firstName"  width="80"/>
			<s:GridColumn dataField="@lastName"  width="80"/>
			<s:GridColumn dataField="@food"  width="80"/>
			<s:GridColumn dataField="@drink"  width="80"/>
		</s:ArrayList>
	
	</fx:Declarations>
	
	
	<fx:Script>
		<![CDATA[
			//common include file defines some helper/utility methods
			include "assets/common.as";
			import spark.components.DataGrid;
			import spark.components.Grid;
			import spark.components.gridClasses.CellPosition;
			import mx.collections.IList;
			import mx.collections.ArrayCollection;
			import mx.collections.XMLListCollection;
			import spark.collections.Sort;
			import spark.collections.SortField;
			import components.*;
			use namespace mx_internal;
			[Bindable]
			public var gridDataCollection:ArrayCollection = new ArrayCollection();
			[Bindable]
			public var dataGridDataCollection:ArrayCollection = new ArrayCollection();
			
			public var filterText:String;
			public var testDG:DataGrid;
			
			/**
			* this method is to insert columns on a dataGrid. The new columns will be added after columnIndex, total
			* column counts is set by columnCount
			*/
			public function insertNewColumns(grid:DataGrid,columnIndex:int, columnCount:int):void
			{
				
				for (var i:int=0;i<columnCount;i++)
					createColumn2(dataGrid,i);
				
			}				
			/**
			* this method is to add 5 more new items on a dataGrid starting from the startIndex.
			*/
			public function insertItems(dataGrid:DataGrid,startIndex:int):void
			{
				for (var i:int = 0; i < 5; i++)
				    dataGrid.dataProvider.addItemAt(createItem(100 + i), startIndex);
				
			}
			
			/**
			* this method is to remove 5 items on a dataGrid starting from startIndex
			*/
			public function removeItems(dataGrid:DataGrid,startIndex:int):void
			{

				for (var i:int = 4; i >=0; i--)
				    dataGrid.dataProvider.removeItemAt(i + startIndex);
			}
			/**
			* this method is to update dataGrid item on itemIndex=index, it sets property 'firstName' to 'blablabla'
			*/
			public function updateItems(grid:DataGrid,index:int):void
			{
				var obj:Object=grid.dataProvider.getItemAt(index);
				obj['firstName']="blablabla";
				trace(grid.dataProvider.getItemAt(index)['firstName']);
				grid.dataProvider.itemUpdated(grid.dataProvider.getItemAt(index),"firstName",grid.dataProvider.getItemAt(index)['firstName'],"blablabla");
			}
			/**
			* this method is to replace datagrid item which index=index parameter, new item is newly created on
			*/
			public function replaceItems(grid:DataGrid,index:int):void
			{
				grid.dataProvider.setItemAt(this.createItem(index+1000),index);

			}
			/**
			* this method is to replace datagrid item which index=index parameter, new item is newly created on
			*/
			public function replaceItems2(grid:DataGrid,index:int,newItem:Object):void
			{
				grid.dataProvider.setItemAt(newItem,index);

			}			
			/**
			* this method is to apply sort on dataGrid based on dataGrid item field=fieldName.
			* it handls the dataGrid is ArrayCollection or XMLListCollection two cases
			*/
			public function applySort(grid:DataGrid,fieldName:String, descending:Boolean=false):void
			{
				var sortField:SortField;
				var mySort:Sort=new Sort();
				
				if (grid.dataProvider is ArrayCollection)
				{
					
					ArrayCollection(grid.dataProvider).sort = mySort;
					sortField=new SortField(fieldName);
					sortField.setStyle("locale", "en-US");
					sortField.descending=descending;
					ArrayCollection(grid.dataProvider).sort.fields = [sortField ];
					ArrayCollection(grid.dataProvider).refresh();
				}else if (grid.dataProvider is XMLListCollection)
				{
					XMLListCollection(grid.dataProvider).sort = mySort;
					sortField=new SortField("@"+fieldName);
					sortField.setStyle("locale", "en-US");
					sortField.descending=descending;
					XMLListCollection(grid.dataProvider).sort.fields = [sortField ];
					XMLListCollection(grid.dataProvider).refresh();
				}

			}
			/**
			* this method is to apply sort on a list based on field=fieldName.
			* it handls the IList is ArrayCollection or XMLListCollection two cases
			*/
			public function applySortOnList(dp:IList,fieldName:String, descending:Boolean=false):void
			{
				var sortField:SortField;
				var mySort:Sort=new Sort();
				
				if (dp is ArrayCollection)
				{
					ArrayCollection(dp).sort = mySort;
					sortField=new SortField(fieldName);
					sortField.setStyle("locale", "en-US");
					sortField.descending=descending;
					ArrayCollection(dp).sort.fields = [sortField ];
					ArrayCollection(dp).refresh();
				}else if (dp is XMLListCollection)
				{
					XMLListCollection(dp).sort = mySort;
					sortField=new SortField("@"+fieldName);
					sortField.setStyle("locale", "en-US");
					sortField.descending=descending;
					XMLListCollection(dp).sort.fields = [sortField ];
					XMLListCollection(dp).refresh();
				}

			}
			
			/**
			* this method is a filter method based on filterText which is a global variable.
			* it handles an item is either object or XML
			*/
			public function includeFirstNameContain( item:Object ):Boolean
			{
				if (item is XML)
				{
					if (filterText.indexOf("*")>-1)
					return true;
					if( (XML(item).@firstName).indexOf(filterText)>-1)
						return true;
					else return false;
				}else 
				{
					if( String(item["firstName"]).indexOf(filterText)>-1)
						return false;
					else return true;
				}
			}
			
			// set the filter function on the collection
			public function applyFilter(grid:DataGrid):void
			{
				if (grid.dataProvider is ArrayCollection)
				{
					ArrayCollection(grid.dataProvider).filterFunction = includeFirstNameContain;
					ArrayCollection(grid.dataProvider).refresh();
				}else if (grid.dataProvider is XMLListCollection)
				{
					XMLListCollection(grid.dataProvider).filterFunction = includeFirstNameContain;
					XMLListCollection(grid.dataProvider).refresh();
				}
			}
			/**
			* this method is a helper method, try to create an arrayList with rowIndex/columnIndex
			*/
			public function addSelectedCellRegion(rows:Vector.<int>, columnIndex:int, columnCount:int):ArrayList
			{
				var selectedCellInfo:ArrayList=new ArrayList();
				var len:int=rows.length;
				var rowIndex:int;
				for (var i:int=0;i<len;i++)
				{
						rowIndex=rows.pop();
						for (var j:int=0;j<columnCount;j++)
						selectedCellInfo.addItem({"rowIndex":rowIndex, "columnIndex":(columnIndex+j)});
				}
				return selectedCellInfo;
				
			}			
			//get row item based on row indices vector
			public function getItems(grid:DataGrid,v:Vector.<int>):ArrayList
			{
				var rowsHolder:ArrayList=new ArrayList();
				var len:int=v.length;
				var obj:Object;
				for (var i:int =0;i<len;i++)
				{
					obj=grid.dataProvider.getItemAt(v.pop());
					rowsHolder.addItem(obj);
				}
				return rowsHolder;

											
			}
			//get new row indices based on row object
			public function getNewIndices(grid:DataGrid,items:ArrayList):Vector.<int>
			{
				var v:Vector.<int>=new Vector.<int>;
				var t:int;
				var obj:Object;
				for (var i:int =0;i<items.length;i++){
					obj=items.getItemAt(i);
					t=grid.dataProvider.getItemIndex(obj);
					v.push(t);
				}
				return v;
			}
			
			
			//get new row indices based on row object
			public function getNewIndices2(grid:DataGrid,items:ArrayList):Vector.<Object>
			{
				var v:Vector.<Object>=new Vector.<Object>;
				var t:int;
				var obj:Object;
				for (var i:int =0;i<items.length;i++){
					obj=items.getItemAt(i);
					t=grid.dataProvider.getItemIndex(obj);
					trace("###"+obj["index"]+";new index="+t);
					v.push({oldIndex:obj["index"], newIndex:t});
				}
				return v;
			}		
			public function setCollectionChangeListener(grid:DataGrid):void
			{
				grid.addEventListener("collectionChange",collectionChangeHandler);
			}
			public function removeCollectionChangeListener(grid:DataGrid):void
			{
				grid.removeEventListener("collectionChange",collectionChangeHandler);
			}
            		public function collectionChangeHandler(e:mx.events.CollectionEvent):void
			{
				if (e.currentTarget is DataGrid)
				{
					DataGrid(e.currentTarget).grid.gridSelection.dataProviderCollectionChanged(e);
					dispatchEvent(new FlexEvent("collectionChanged"));
				}
			}
			/**
			* this method is to verify whether dataGrid selected rows is same as row indices Vector.
			* if not contains the row index from the vector, error message will be set,otherwise if all rows contained, return empty string
			* a helper method for mustella to verify method call with a little more helpful error message
			*/
			public function verifySelectedRows(dataGrid:DataGrid,v:Vector.<int>):String
			{	
				var t:int;
				var errMsg:String="";
				var len:int=v.length;
			
				var v1:Vector.<int>=dataGrid.selectedIndices;
				var len2:int=v1.length;
				for (var i:int=0;i<len2;i++)
				trace("$$$$"+v1.pop());
				for (i=0;i<len;i++)
				{
					t=int(v.pop());
					if (!dataGrid.selectionContainsIndex(t))
						errMsg+="row "+t+" not in selection\n";
				}
				return errMsg;


			}	
			/**
			* this method was created before dataGrid method to check all rows selected.
			*/
			public function verifyAllRowSelected(grid:DataGrid):String
			{
				var errMsg:String="";
				for (var i:int=0;i<grid.dataProvider.length;i++)
				{
					if (!grid.selectionContainsIndex(i) )
					errMsg+="row "+i+" Not in selection, expect to be in selection\n";
				}
				return errMsg;
			}
		
			/**
			* this method is a helper method to dump selected rowIndex/columnIndex
			*/
			public function displayArrayList(arr:ArrayList):void
			{
				var n:int=arr.length;
				var obj:Object;
				for (var j:int=0;j<n;j++)
				{
					obj=arr.getItemAt(j);
					trace("[rowIndex="+obj["rowIndex"]+",columnIndex="+obj["columnIndex"]+"]");
				}
			}
			/**
			* this method is to verify selected cells from tobeCheckedCells is correct, if not, error message will be returned.
			* this method also was created early before dataGrid cellselection verification method is available.
			*/
			public function verifySelectedCells(dataGrid:DataGrid,tobeCheckedCells:ArrayList):String
			{	
				var t:Object;
				var errMsg:String="";
				var len:int=tobeCheckedCells.length;
			
				var v1:Vector.<CellPosition>=dataGrid.selectedCells;
				var len2:int=v1.length;
				var obj:CellPosition;
				for (var i:int=0;i<len2;i++)
				{
					obj=CellPosition(v1.pop());
					trace("selected cell:["+obj.toString());
				}
				for (i=0;i<len;i++)
				{
					t=tobeCheckedCells.getItemAt(i);
					if (!dataGrid.selectionContainsCell(t["rowIndex"],t["columnIndex"]))
						errMsg+="cell [ "+t["rowIndex"]+","+t["columnIndex"]+"] not in selection\n";
				}
				return errMsg;


			}
			/**
			* this method is helper method, check tobeCheckedCells are the only selected cells, created before dataGrid corresponding method is available
			*/
			public function verifyOnlySelectedCells(dataGrid:DataGrid, tobeCheckedCells:ArrayList):String
			{	
				var t:Object;
				var errMsg:String="";
				var len:int=tobeCheckedCells.length;
			
				var v1:Vector.<CellPosition>=dataGrid.selectedCells;
				
				var len2:int=v1.length;
				if (len2!=len) errMsg+="all cells count is different:"+len2+";passed cell count="+len+"\n";
				return verifySelectedCells(dataGrid,tobeCheckedCells);


			}
			/**
			* this method to verify two vectors are equal or not
			*/
			public function verifyIndices(v1:Vector.<int>,v2:Vector.<int>):String
			{
			
				v1.fixed=false;
				v2.fixed=false;
				
				var tmp1:ArrayCollection=new ArrayCollection();
				var len:int=v1.length;
				var len2:int=v2.length;
				if (len!=len2)
				{
					return "two vectors are not equal in lenght, actual len="+len+";expect len="+len2+"\n";
				}
				var j:int=len;
				while(j-->0)
				{
					tmp1.addItem({"data":int(v1.pop())});
				}
				var tmp2:ArrayCollection=new ArrayCollection();
				j=len2;
				while(j-->0)
				{
					tmp2.addItem({"data":int(v2.pop())});
				}
				
				tmp1.sort=new Sort();
				var sortField:SortField;
				sortField=new SortField("data");
				sortField.setStyle("locale", "en-US");
				tmp1.sort.fields = [ sortField];
				tmp1.refresh();
				var sortField2:SortField;
				
				tmp2.sort=new Sort();
				sortField2= new SortField("data");
				sortField2.setStyle("locale", "en-US");
				tmp2.sort.fields = [sortField2];
				tmp2.refresh();
				
				var errMsg:String="";
				
				var d1:int, d2:int;
				var i:int;
				for (i=0;i<len;i++)
				{	
					d1=int(tmp1.getItemAt(i).data);
					d2=int(tmp2.getItemAt(i).data);
					if (d1!=d2)
						errMsg+="index "+i+" not expect, actual="+d1+";expect="+d2+"\n";
				}
					return errMsg;
			}
			
			/**
			* v: is the allCells() return, cells: is the expected selected cells info
			* this method is to verify all selected cells is expected from dataGrid.allCells
			*/
			public function verifyAllCellsResult(v:Vector.<Object>,cells:ArrayList):String
			{
				var n:int=v.length;
				var errMsg:String="";
				if (n!=cells.length)
				{
					errMsg+="length not equal";
					return errMsg;
				}
				var arr:Array=new Array();
				for (var i:int=0;i<n;i++)
					arr[i]=v.pop();
				var found:Boolean=false;
				var targetObj:Object;
				for (i=0;i<n;i++)
				{
					found=false;
					for (var j:int=0;j<n;j++)
					{
						targetObj=cells.getItemAt(j);
						if (arr[i].rowIndex==targetObj["rowIndex"] && arr[i].columnIndex==targetObj["columnIndex"])
						{
							found=true;
							cells.removeItemAt(j);
							break;
						}
					}
					if (!found)
					errMsg+="["+arr[i].rowIndex+","+arr[i].columnIndex+"] not found \n";
				}
				return errMsg;
			}
						
		]]>
	</fx:Script>
	<s:layout>
		<s:HorizontalLayout/>
	</s:layout>
	<s:VGroup>
		<s:Label id="label1" text="label holder" height="100"/>
		<s:VGroup id="vg" height="{dataGrid.height+25}">
		<comps:DataGrid_comp1 id="dataGrid" />
		</s:VGroup>
		<comps:DataGrid_dp_arrayList id="dg_arrList" />

		<s:HGroup><!-- components used for sorting -->
			<comps:DataGrid_sort_noData id="dg1" />
			<comps:DataGrid_no_explicit_columns id="dg2" />
		</s:HGroup>
		<comps:DataGrid_Custom_IRs2 id="dg3"/>
	</s:VGroup>
	<s:HGroup>
		<comps:DataGrid_editable_comp1 id="dg4"/>
		<comps:DataGrid_sort_locale id="dg5" />
	</s:HGroup>
		
</s:Application>