<?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:Module xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx"
			   width="100%" height="100%">
	
	<fx:Script>
		<![CDATA[
			import mx.collections.ArrayCollection;
			import mx.events.FlexEvent;
			
			import spark.validators.supportClasses.GlobalizationValidatorBase;
			
			[Bindable]
			private var _locales:ArrayCollection = new ArrayCollection(['en-US','de-DE','ja-JP','ru-RU','zh-CN','fr-FR']);
			
			protected function localeCB_updateCompleteHandler(event:FlexEvent):void
			{
				this.setStyle('locale',localeCB.selectedItem);
			}
			
			protected function button1_clickHandler(event:MouseEvent):void
			{
				var _validatorsArr:Array = [cv1,cv2,cv3,cv4,cv5];
				
				GlobalizationValidatorBase.validateAll(_validatorsArr);
			}
			
		]]>
	</fx:Script>
	
	<fx:Declarations>
		<!--Click Tab key to validate the number-->
		<s:CurrencyValidator id="cv1" source="{currTI1}" property="text"/>
		<s:CurrencyValidator id="cv2" source="{currTI2}" property="text"/>
		<s:CurrencyValidator id="cv3" source="{currTI3}" property="text" fractionalDigits="2"/>
		<s:CurrencyValidator id="cv4" source="{currTI4}" property="text" minValue="20" maxValue="200"/>
		<s:CurrencyValidator id="cv5" source="{currTI5}" property="text" domain="int"/>
	</fx:Declarations>
	
	<s:Panel title="Spark CurrencyValidator" width="100%" height="100%">

		<s:layout>
			<s:HorizontalLayout paddingLeft="10" paddingRight="10" paddingTop="10" paddingBottom="10" />
		</s:layout>
			
		<s:Form height="100%" width="100%">
			<s:Label text="Create some criterions and validate the input number: "/>
			<s:Spacer height="15"/>
			<s:FormItem label="Locale:">
				<s:ComboBox id="localeCB" dataProvider="{_locales}" selectedIndex="0" updateComplete="localeCB_updateCompleteHandler(event)"/>
			</s:FormItem>
			<s:Label text="============================================================================"/>
			<s:FormItem label="Currency symbol and ISO code based on current locale are:">
				<s:HGroup>
					<s:Label id="symbolL" text="Currency symbol:  {cv1.currencySymbol}"/>
					<s:Label id="isoL" text="Currency ISO code:  {cv1.currencyISOCode}"/>
				</s:HGroup>
			</s:FormItem>
			<s:FormItem label="Please enter an integer currency number with currency symbol:">
				<s:TextInput id="currTI1" text="{cv1.currencySymbol}" 
							 toolTip="Here is the correct currency symbol of current locale, please continue enter numbers to validate"/>
			</s:FormItem>
			<s:FormItem label="Please enter an integer currency number with currency ISO code:">
				<s:TextInput id="currTI2" text="{cv1.currencyISOCode}" 
							 toolTip="Here is the correct currency ISO code of current locale, please continue enter numbers to validate"/>
			</s:FormItem>
			<s:FormItem label="Please enter a currency number with at most two fractional digits:">
				<s:TextInput id="currTI3" 
							 toolTip="decimal separator of current locale is {cv3.decimalSeparator}"/>
			</s:FormItem>
			<s:FormItem label="Please enter a currency number between 20 and 200:">
				<s:TextInput id="currTI4"/>
			</s:FormItem>
			<s:FormItem label="Please enter an integer currency number:">
				<s:TextInput id="currTI5"/>
			</s:FormItem>
			<s:FormItem label="Click the button to validate all inputted currency number:">
				<s:HGroup>
					<s:Button label="Validate All" click="button1_clickHandler(event)"/>
					<s:Label id="resultL"/>
				</s:HGroup>
			</s:FormItem>
		</s:Form>

	</s:Panel>
</s:Module>
