textLayout/src/flashx/textLayout/property/Property.as - flex-tlf - Git at Google

 ////////////////////////////////////////////////////////////////////////////////
 //
 //  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.
 //
 ////////////////////////////////////////////////////////////////////////////////
 package flashx.textLayout.property
 {
 	import flashx.textLayout.debug.assert;
 	import flashx.textLayout.elements.GlobalSettings;
 	import flashx.textLayout.formats.FormatValue;
 	import flashx.textLayout.formats.ListMarkerFormat;
 	import flashx.textLayout.formats.TextLayoutFormat;
 	import flashx.textLayout.tlf_internal;

 	use namespace tlf_internal;

 	[ExcludeClass]
 	/** Base class of property metadata.  Each property in the various TextLayout attributes structures has a metadata singletion Property class instance.  The instance
 	 * can be used to process the property to and from xml, find out range information and help with the attribute cascade.  The Property class also contains static functions
 	 * for processing all the properties collected in a TextLayout Format object. @private  */
 	public class Property
 	{
 		public static var errorHandler:Function = defaultErrorHandler;
 		public static function defaultErrorHandler(p:Property,value:Object):void
 		{
 			throw(new RangeError(createErrorString(p,value)));
 		}
 		public static function createErrorString(p:Property,value:Object):String
 		{
 			return GlobalSettings.resourceStringFunction("badPropertyValue",[ p.name, value.toString() ])
 		}

 		// shared propertyHandler instances
 		/** @private */
 		tlf_internal static const sharedStringHandler:StringPropertyHandler = new StringPropertyHandler();
 		/** @private */
 		tlf_internal static const sharedInheritEnumHandler:EnumPropertyHandler = new EnumPropertyHandler([ FormatValue.INHERIT ]);
 		/** @private */
 		tlf_internal static const sharedUndefinedHandler:UndefinedPropertyHandler = new UndefinedPropertyHandler();
 		/** @private */
 		tlf_internal static const sharedUintHandler:UintPropertyHandler = new UintPropertyHandler();
 		/** @private */
 		tlf_internal static const sharedBooleanHandler:BooleanPropertyHandler = new BooleanPropertyHandler();

 		/** @private */
 		tlf_internal static const sharedTextLayoutFormatHandler:FormatPropertyHandler = new FormatPropertyHandler();
 		/** @private */
 		tlf_internal static const sharedListMarkerFormatHandler:FormatPropertyHandler = new FormatPropertyHandler();

 		public static function NewBooleanProperty(nameValue:String, defaultValue:Boolean, inherited:Boolean, categories:Vector.<String>):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,sharedBooleanHandler,sharedInheritEnumHandler);
 			return rslt;
 		}

 		public static function NewStringProperty(nameValue:String, defaultValue:String, inherited:Boolean, categories:Vector.<String>):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,sharedStringHandler);
 			return rslt;
 		}
 		public static function NewUintProperty(nameValue:String, defaultValue:uint, inherited:Boolean, categories:Vector.<String>):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,sharedUintHandler,sharedInheritEnumHandler);
 			return rslt;
 		}

 		public static function NewEnumStringProperty(nameValue:String, defaultValue:String, inherited:Boolean, categories:Vector.<String>, ... rest):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),sharedInheritEnumHandler);
 			return rslt;
 		}

 		public static function NewIntOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:int, maxValue:int, ... rest):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),new IntPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
 			return rslt;
 		}

 		public static function NewUintOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>,  ... rest):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),sharedUintHandler,sharedInheritEnumHandler);
 			return rslt;
 		}

 		public static function NewNumberProperty(nameValue:String, defaultValue:Number, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
 			return rslt;
 		}
 		public static function 	NewNumberOrPercentOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number, minPercentValue:String, maxPercentValue:String, ... rest):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),new PercentPropertyHandler(minPercentValue,maxPercentValue),new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
 			return rslt;
 		}
 		public static function NewNumberOrPercentProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number, minPercentValue:String, maxPercentValue:String):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new PercentPropertyHandler(minPercentValue,maxPercentValue),new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
 			return rslt;
 		}
 		public static function NewNumberOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number, ... rest):Property
 		{
 			var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
 			return rslt;
 		}
 		public static function NewTabStopsProperty(nameValue:String, defaultValue:Array, inherited:Boolean, categories:Vector.<String>):Property
 		{
 			return new TabStopsProperty(nameValue,defaultValue,inherited,categories);
 		}
 		public static function NewSpacingLimitProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minPercentValue:String, maxPercentValue:String):Property
 		{
 			var rslt:Property = new Property(nameValue,defaultValue,inherited,categories);
 			rslt.addHandlers(sharedUndefinedHandler, new SpacingLimitPropertyHandler(minPercentValue, maxPercentValue), sharedInheritEnumHandler);
 			return rslt;
 		}

 		private static const undefinedValue:* = undefined;

 		public static function NewTextLayoutFormatProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>):Property
 		{
 			// passing undefined as a value seems to confuse the compiler
 			var rslt:Property = new Property(nameValue, undefinedValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,sharedTextLayoutFormatHandler,sharedInheritEnumHandler);
 			return rslt;
 		}
 		public static function NewListMarkerFormatProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>):Property
 		{
 			// passing undefined as a value seems to confuse the compiler
 			var rslt:Property = new Property(nameValue, undefinedValue, inherited, categories);
 			rslt.addHandlers(sharedUndefinedHandler,sharedListMarkerFormatHandler,sharedInheritEnumHandler);
 			return rslt;
 		}
 		/** not yet enabled.  @private */
 		public static const NO_LIMITS:String ="noLimits";
 		/** not yet enabled.  @private */
 		public static const LOWER_LIMIT:String ="lowerLimit";
 		/** not yet enabled.  @private */
 		public static const UPPER_LIMIT:String = "upperLimit";
 		/** not yet enabled.  @private */
 		public static const ALL_LIMITS:String = "allLimits";

 		// storing name here is redundant but is more efficient
 		private var _name:String;
 		private var _default:*;
 		private var _inherited:Boolean;
 		private var _categories:Vector.<String>;
 		private var _hasCustomExporterHandler:Boolean;
 		private var _numberPropertyHandler:NumberPropertyHandler;

 		protected var _handlers:Vector.<PropertyHandler>;

 		/** Initializer.  Each property has a name and a default. */
 		public function Property(nameValue:String,defaultValue:*,inherited:Boolean,categories:Vector.<String>)
 		{
 			_name = nameValue;
 			_default = defaultValue;
 			_inherited = inherited;
 			_categories = categories;
 			_hasCustomExporterHandler = false;
 		}

 		/** The name of the property */
 		public function get name():String
 		{ return _name; }

 		/** The default value of this property */
 		public function get defaultValue():*
 		{ return _default; }

 		/** Is this property inherited */
 		public function get inherited():Object
 		{ return _inherited; }

 		/** First listed Category of this property. This is the legacy category from when Properties could only be in one category.  */
 		public function get category():String
 		{ return _categories[0]; }

 		/** Return the list of categories */
 		public function get categories():Vector.<String>
 		{ return _categories; }

 		public function addHandlers(... rest):void
 		{
 			_handlers = new Vector.<PropertyHandler>(rest.length,true);
 			for (var idx:int = 0; idx < rest.length; idx++)
 			{
 				var handler:PropertyHandler = rest[idx]
 				_handlers[idx] = handler;
 				if (handler.customXMLStringHandler)
 					_hasCustomExporterHandler = true;
 				if (handler is NumberPropertyHandler)
 					_numberPropertyHandler = handler as NumberPropertyHandler;
 			}
 		}

 		public function findHandler(handlerClass:Class):PropertyHandler
 		{
 			for each (var prop:PropertyHandler in _handlers)
 			{
 				if (prop is handlerClass)
 					return prop;
 			}
 			return null;
 		}

 		/** Helper function when setting the property */
 		public function setHelper(currVal:*,newVal:*):*
 		{
 			for each (var handler:PropertyHandler in _handlers)
 			{
 				var checkRslt:* = handler.owningHandlerCheck(newVal);
 				if (checkRslt !== undefined)
 					return handler.setHelper(checkRslt);
 			}

 			Property.errorHandler(this,newVal);
 			return currVal;
 		}

 		/** Helper function when merging the property to compute actual attributes */
 		public function concatInheritOnlyHelper(currVal:*,concatVal:*):*
 		{ return (_inherited && currVal === undefined) || currVal == FormatValue.INHERIT ? concatVal : currVal; }

 		public static function defaultConcatHelper(currVal:*,concatVal:*):*
 		{ return currVal === undefined || currVal == FormatValue.INHERIT ? concatVal : currVal; }

 		/** Helper function when merging the property to compute actual attributes */
 		public function concatHelper(currVal:*,concatVal:*):*
 		{
 			if (_inherited)
 				return currVal === undefined || currVal == FormatValue.INHERIT ? concatVal : currVal;
 			if (currVal === undefined)
 				return defaultValue;
 			return currVal == FormatValue.INHERIT ? concatVal : currVal;
 		}

 		/** Helper function when comparing the property */
 		public function equalHelper(v1:*,v2:*):Boolean
 		{ return v1 == v2; }

 		/** Convert the value of this property to a string appropriate for XML export */
 		public function toXMLString(val:Object):String
 		{
 			if (_hasCustomExporterHandler)
 			{
 				for each (var prop:PropertyHandler in _handlers)
 				{
 					if (prop.customXMLStringHandler && prop.owningHandlerCheck(val) !== undefined)
 						return prop.toXMLString(val);
 				}
 			}
 			return val.toString();
 		}

 		public function get maxPercentValue():Number
 		{
 			var handler:PercentPropertyHandler = findHandler(PercentPropertyHandler) as PercentPropertyHandler;
 			return handler ? handler.maxValue : NaN;
 		}
 		public function get minPercentValue():Number
 		{
 			var handler:PercentPropertyHandler = findHandler(PercentPropertyHandler) as PercentPropertyHandler;
 			return handler ? handler.minValue : NaN;
 		}
 		public function get minValue():Number
 		{
 			var numberHandler:NumberPropertyHandler = findHandler(NumberPropertyHandler) as NumberPropertyHandler;
 			if (numberHandler)
 				return numberHandler.minValue;
 			var intHandler:IntPropertyHandler = findHandler(IntPropertyHandler) as IntPropertyHandler;
 			return intHandler ? intHandler.minValue : NaN;
 		}
 		public function get maxValue():Number
 		{
 			var numberHandler:NumberPropertyHandler = findHandler(NumberPropertyHandler) as NumberPropertyHandler;
 			if (numberHandler)
 				return numberHandler.maxValue;
 			var intHandler:IntPropertyHandler = findHandler(IntPropertyHandler) as IntPropertyHandler;
 			return intHandler ? intHandler.maxValue : NaN;
 		}

 		public function computeActualPropertyValue(propertyValue:Object,percentInput:Number):Number
 		{
 			var percent:Number = toNumberIfPercent(propertyValue);
 			if (isNaN(percent))
 				return Number(propertyValue);

 			// its a percent - calculate and clamp
 			var rslt:Number =  percentInput * (percent / 100);
 			return _numberPropertyHandler ? _numberPropertyHandler.clampToRange(rslt) : rslt;
 		}

 		// /////////////////////////////////////////////
 		// Following static functions are used by Format classes to
 		// perform functions that iterate over all the attributes.
 		// They are driven by the attributes metadata object that contains
 		// definitions for all the properties.
 		// /////////////////////////////////////////////

 		/** Helper function to initialize all property values from defaults. */
 		static public function defaultsAllHelper(description:Object,current:Object):void
 		{
 			for each (var prop:Property in description)
 				current[prop.name] = prop.defaultValue;
 		}

 		/** Helper function to compare two sets of properties. */
 		static public function equalAllHelper(description:Object,p1:Object,p2:Object):Boolean
 		{
 			if (p1 == p2)
 				return true;
 			// these could be "equal" if all attributes of p1 or p2 are null
 			if (p1 == null || p2 == null)
 				return false;
 			for each (var prop:Property in description)
 			{
 				var name:String = prop.name;
 				if (!(prop.equalHelper(p1[name],p2[name])))
 					return false;
 			}
 			return true;
 		}

 		static public function extractInCategory(formatClass:Class,description:Object,props:Object,category:String,legacy:Boolean = true):Object
 		{
 			var rslt:Object = null;
 			for each (var prop:Property in description)
 			{
 				if (props[prop.name] == null)
 					continue;

 				if (legacy)
 				{
 					if (prop.category != category)
 						continue;
 				}
 				else if (prop.categories.indexOf(category) == -1)
 					continue;

 				if (rslt == null)
 					rslt = new formatClass();
 				rslt[prop.name] = props[prop.name];
 			}
 			return rslt;
 		}

 		/** @private Copy an object */
 		static public function shallowCopy(src:Object):Object
 		{
 			// make a shallow copy
 			var rslt:Object = new Object()
 			for (var val:Object in src)
 				rslt[val] = src[val];
 			return rslt;
 		}

 		/** @private Copy properties from src to result if a property of the same name exists in filter */
 		static public function shallowCopyInFilter(src:Object,filter:Object):Object
 		{
 			// make a shallow copy
 			var rslt:Object = new Object()
 			for (var val:Object in src)
 			{
 				if (filter.hasOwnProperty(val))
 					rslt[val] = src[val];
 			}
 			return rslt;
 		}

 		/** @private Copy properties from src to result if a property of the same name exists in filter */
 		static public function shallowCopyNotInFilter(src:Object,filter:Object):Object
 		{
 			// make a shallow copy
 			var rslt:Object = new Object()
 			for (var val:Object in src)
 			{
 				if (!filter.hasOwnProperty(val))
 					rslt[val] = src[val];
 			}
 			return rslt;
 		}

 		static private function compareStylesLoop(o1:Object,o2:Object,description:Object):Boolean
 		{
 			for (var val:String in o1)
 			{
 				var o1val:Object = o1[val];
 				var o2val:Object = o2[val];
 				if (o1val != o2val)
 				{
 					if (!(o1val is Array) || !(o2val is Array) || o1val.length != o2val.length || !description)
 						return false;	// different
 					var prop:ArrayProperty = description[val];
 					if (!prop || !equalAllHelper(prop.memberType.tlf_internal::description,o1val,o2val))
 						return false;
 				}
 			}
 			return true;
 		}
 		/** @private */
 		static tlf_internal const nullStyleObject:Object = new Object();
 		/** @private */
 		static public function equalStyles(o1:Object,o2:Object,description:Object):Boolean
 		{
 			if (o1 == null)
 				o1 = nullStyleObject;
 			if (o2 == null)
 				o2 = nullStyleObject;
 			// Use of prototype chains and bug https://bugzilla.mozilla.org/show_bug.cgi?id=447673 requires this two way compare
 			return compareStylesLoop(o1,o2,description) && compareStylesLoop(o2,o1,description);
 		}

 		/** @private */
 		static public function toNumberIfPercent(o:Object):Number
 		{
 			if (!(o is String))
 				return NaN;
 			var s:String = String(o);
 			var len:int = s.length;

 			return len != 0 && s.charAt(len-1) == "%" ? parseFloat(s) : NaN;
 		}

 		static private var prototypeFactory:Function = function():void
 		{ }

 		/** @private Create an object with specified prototype parent */
 		static public function createObjectWithPrototype(parent:Object):Object
 		{
 			prototypeFactory.prototype = parent;
 			return new prototypeFactory();
 		}
 	}
 }
	////////////////////////////////////////////////////////////////////////////////
	//
	// 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.
	//
	////////////////////////////////////////////////////////////////////////////////
	package flashx.textLayout.property
	{
	import flashx.textLayout.debug.assert;
	import flashx.textLayout.elements.GlobalSettings;
	import flashx.textLayout.formats.FormatValue;
	import flashx.textLayout.formats.ListMarkerFormat;
	import flashx.textLayout.formats.TextLayoutFormat;
	import flashx.textLayout.tlf_internal;

	use namespace tlf_internal;

	[ExcludeClass]
	/** Base class of property metadata. Each property in the various TextLayout attributes structures has a metadata singletion Property class instance. The instance
	* can be used to process the property to and from xml, find out range information and help with the attribute cascade. The Property class also contains static functions
	* for processing all the properties collected in a TextLayout Format object. @private */
	public class Property
	{
	public static var errorHandler:Function = defaultErrorHandler;
	public static function defaultErrorHandler(p:Property,value:Object):void
	{
	throw(new RangeError(createErrorString(p,value)));
	}
	public static function createErrorString(p:Property,value:Object):String
	{
	return GlobalSettings.resourceStringFunction("badPropertyValue",[ p.name, value.toString() ])
	}

	// shared propertyHandler instances
	/** @private */
	tlf_internal static const sharedStringHandler:StringPropertyHandler = new StringPropertyHandler();
	/** @private */
	tlf_internal static const sharedInheritEnumHandler:EnumPropertyHandler = new EnumPropertyHandler([ FormatValue.INHERIT ]);
	/** @private */
	tlf_internal static const sharedUndefinedHandler:UndefinedPropertyHandler = new UndefinedPropertyHandler();
	/** @private */
	tlf_internal static const sharedUintHandler:UintPropertyHandler = new UintPropertyHandler();
	/** @private */
	tlf_internal static const sharedBooleanHandler:BooleanPropertyHandler = new BooleanPropertyHandler();

	/** @private */
	tlf_internal static const sharedTextLayoutFormatHandler:FormatPropertyHandler = new FormatPropertyHandler();
	/** @private */
	tlf_internal static const sharedListMarkerFormatHandler:FormatPropertyHandler = new FormatPropertyHandler();

	public static function NewBooleanProperty(nameValue:String, defaultValue:Boolean, inherited:Boolean, categories:Vector.<String>):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,sharedBooleanHandler,sharedInheritEnumHandler);
	return rslt;
	}

	public static function NewStringProperty(nameValue:String, defaultValue:String, inherited:Boolean, categories:Vector.<String>):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,sharedStringHandler);
	return rslt;
	}
	public static function NewUintProperty(nameValue:String, defaultValue:uint, inherited:Boolean, categories:Vector.<String>):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,sharedUintHandler,sharedInheritEnumHandler);
	return rslt;
	}

	public static function NewEnumStringProperty(nameValue:String, defaultValue:String, inherited:Boolean, categories:Vector.<String>, ... rest):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),sharedInheritEnumHandler);
	return rslt;
	}

	public static function NewIntOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:int, maxValue:int, ... rest):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),new IntPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
	return rslt;
	}

	public static function NewUintOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, ... rest):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),sharedUintHandler,sharedInheritEnumHandler);
	return rslt;
	}

	public static function NewNumberProperty(nameValue:String, defaultValue:Number, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
	return rslt;
	}
	public static function NewNumberOrPercentOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number, minPercentValue:String, maxPercentValue:String, ... rest):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),new PercentPropertyHandler(minPercentValue,maxPercentValue),new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
	return rslt;
	}
	public static function NewNumberOrPercentProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number, minPercentValue:String, maxPercentValue:String):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new PercentPropertyHandler(minPercentValue,maxPercentValue),new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
	return rslt;
	}
	public static function NewNumberOrEnumProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minValue:Number, maxValue:Number, ... rest):Property
	{
	var rslt:Property = new Property(nameValue, defaultValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,new EnumPropertyHandler(rest),new NumberPropertyHandler(minValue,maxValue),sharedInheritEnumHandler);
	return rslt;
	}
	public static function NewTabStopsProperty(nameValue:String, defaultValue:Array, inherited:Boolean, categories:Vector.<String>):Property
	{
	return new TabStopsProperty(nameValue,defaultValue,inherited,categories);
	}
	public static function NewSpacingLimitProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>, minPercentValue:String, maxPercentValue:String):Property
	{
	var rslt:Property = new Property(nameValue,defaultValue,inherited,categories);
	rslt.addHandlers(sharedUndefinedHandler, new SpacingLimitPropertyHandler(minPercentValue, maxPercentValue), sharedInheritEnumHandler);
	return rslt;
	}

	private static const undefinedValue:* = undefined;

	public static function NewTextLayoutFormatProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>):Property
	{
	// passing undefined as a value seems to confuse the compiler
	var rslt:Property = new Property(nameValue, undefinedValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,sharedTextLayoutFormatHandler,sharedInheritEnumHandler);
	return rslt;
	}
	public static function NewListMarkerFormatProperty(nameValue:String, defaultValue:Object, inherited:Boolean, categories:Vector.<String>):Property
	{
	// passing undefined as a value seems to confuse the compiler
	var rslt:Property = new Property(nameValue, undefinedValue, inherited, categories);
	rslt.addHandlers(sharedUndefinedHandler,sharedListMarkerFormatHandler,sharedInheritEnumHandler);
	return rslt;
	}
	/** not yet enabled. @private */
	public static const NO_LIMITS:String ="noLimits";
	/** not yet enabled. @private */
	public static const LOWER_LIMIT:String ="lowerLimit";
	/** not yet enabled. @private */
	public static const UPPER_LIMIT:String = "upperLimit";
	/** not yet enabled. @private */
	public static const ALL_LIMITS:String = "allLimits";

	// storing name here is redundant but is more efficient
	private var _name:String;
	private var _default:*;
	private var _inherited:Boolean;
	private var _categories:Vector.<String>;
	private var _hasCustomExporterHandler:Boolean;
	private var _numberPropertyHandler:NumberPropertyHandler;

	protected var _handlers:Vector.<PropertyHandler>;

	/** Initializer. Each property has a name and a default. */
	public function Property(nameValue:String,defaultValue:*,inherited:Boolean,categories:Vector.<String>)
	{
	_name = nameValue;
	_default = defaultValue;
	_inherited = inherited;
	_categories = categories;
	_hasCustomExporterHandler = false;
	}

	/** The name of the property */
	public function get name():String
	{ return _name; }

	/** The default value of this property */
	public function get defaultValue():*
	{ return _default; }

	/** Is this property inherited */
	public function get inherited():Object
	{ return _inherited; }

	/** First listed Category of this property. This is the legacy category from when Properties could only be in one category. */
	public function get category():String
	{ return _categories[0]; }

	/** Return the list of categories */
	public function get categories():Vector.<String>
	{ return _categories; }

	public function addHandlers(... rest):void
	{
	_handlers = new Vector.<PropertyHandler>(rest.length,true);
	for (var idx:int = 0; idx < rest.length; idx++)
	{
	var handler:PropertyHandler = rest[idx]
	_handlers[idx] = handler;
	if (handler.customXMLStringHandler)
	_hasCustomExporterHandler = true;
	if (handler is NumberPropertyHandler)
	_numberPropertyHandler = handler as NumberPropertyHandler;
	}
	}

	public function findHandler(handlerClass:Class):PropertyHandler
	{
	for each (var prop:PropertyHandler in _handlers)
	{
	if (prop is handlerClass)
	return prop;
	}
	return null;
	}

	/** Helper function when setting the property */
	public function setHelper(currVal:,newVal:):*
	{
	for each (var handler:PropertyHandler in _handlers)
	{
	var checkRslt:* = handler.owningHandlerCheck(newVal);
	if (checkRslt !== undefined)
	return handler.setHelper(checkRslt);
	}

	Property.errorHandler(this,newVal);
	return currVal;
	}

	/** Helper function when merging the property to compute actual attributes */
	public function concatInheritOnlyHelper(currVal:,concatVal:):*
	{ return (_inherited && currVal === undefined) \|\| currVal == FormatValue.INHERIT ? concatVal : currVal; }

	public static function defaultConcatHelper(currVal:,concatVal:):*
	{ return currVal === undefined \|\| currVal == FormatValue.INHERIT ? concatVal : currVal; }

	/** Helper function when merging the property to compute actual attributes */
	public function concatHelper(currVal:,concatVal:):*
	{
	if (_inherited)
	return currVal === undefined \|\| currVal == FormatValue.INHERIT ? concatVal : currVal;
	if (currVal === undefined)
	return defaultValue;
	return currVal == FormatValue.INHERIT ? concatVal : currVal;
	}

	/** Helper function when comparing the property */
	public function equalHelper(v1:,v2:):Boolean
	{ return v1 == v2; }

	/** Convert the value of this property to a string appropriate for XML export */
	public function toXMLString(val:Object):String
	{
	if (_hasCustomExporterHandler)
	{
	for each (var prop:PropertyHandler in _handlers)
	{
	if (prop.customXMLStringHandler && prop.owningHandlerCheck(val) !== undefined)
	return prop.toXMLString(val);
	}
	}
	return val.toString();
	}

	public function get maxPercentValue():Number
	{
	var handler:PercentPropertyHandler = findHandler(PercentPropertyHandler) as PercentPropertyHandler;
	return handler ? handler.maxValue : NaN;
	}
	public function get minPercentValue():Number
	{
	var handler:PercentPropertyHandler = findHandler(PercentPropertyHandler) as PercentPropertyHandler;
	return handler ? handler.minValue : NaN;
	}
	public function get minValue():Number
	{
	var numberHandler:NumberPropertyHandler = findHandler(NumberPropertyHandler) as NumberPropertyHandler;
	if (numberHandler)
	return numberHandler.minValue;
	var intHandler:IntPropertyHandler = findHandler(IntPropertyHandler) as IntPropertyHandler;
	return intHandler ? intHandler.minValue : NaN;
	}
	public function get maxValue():Number
	{
	var numberHandler:NumberPropertyHandler = findHandler(NumberPropertyHandler) as NumberPropertyHandler;
	if (numberHandler)
	return numberHandler.maxValue;
	var intHandler:IntPropertyHandler = findHandler(IntPropertyHandler) as IntPropertyHandler;
	return intHandler ? intHandler.maxValue : NaN;
	}

	public function computeActualPropertyValue(propertyValue:Object,percentInput:Number):Number
	{
	var percent:Number = toNumberIfPercent(propertyValue);
	if (isNaN(percent))
	return Number(propertyValue);

	// its a percent - calculate and clamp
	var rslt:Number = percentInput * (percent / 100);
	return _numberPropertyHandler ? _numberPropertyHandler.clampToRange(rslt) : rslt;
	}

	// /////////////////////////////////////////////
	// Following static functions are used by Format classes to
	// perform functions that iterate over all the attributes.
	// They are driven by the attributes metadata object that contains
	// definitions for all the properties.
	// /////////////////////////////////////////////

	/** Helper function to initialize all property values from defaults. */
	static public function defaultsAllHelper(description:Object,current:Object):void
	{
	for each (var prop:Property in description)
	current[prop.name] = prop.defaultValue;
	}

	/** Helper function to compare two sets of properties. */
	static public function equalAllHelper(description:Object,p1:Object,p2:Object):Boolean
	{
	if (p1 == p2)
	return true;
	// these could be "equal" if all attributes of p1 or p2 are null
	if (p1 == null \|\| p2 == null)
	return false;
	for each (var prop:Property in description)
	{
	var name:String = prop.name;
	if (!(prop.equalHelper(p1[name],p2[name])))
	return false;
	}
	return true;
	}

	static public function extractInCategory(formatClass:Class,description:Object,props:Object,category:String,legacy:Boolean = true):Object
	{
	var rslt:Object = null;
	for each (var prop:Property in description)
	{
	if (props[prop.name] == null)
	continue;

	if (legacy)
	{
	if (prop.category != category)
	continue;
	}
	else if (prop.categories.indexOf(category) == -1)
	continue;

	if (rslt == null)
	rslt = new formatClass();
	rslt[prop.name] = props[prop.name];
	}
	return rslt;
	}

	/** @private Copy an object */
	static public function shallowCopy(src:Object):Object
	{
	// make a shallow copy
	var rslt:Object = new Object()
	for (var val:Object in src)
	rslt[val] = src[val];
	return rslt;
	}

	/** @private Copy properties from src to result if a property of the same name exists in filter */
	static public function shallowCopyInFilter(src:Object,filter:Object):Object
	{
	// make a shallow copy
	var rslt:Object = new Object()
	for (var val:Object in src)
	{
	if (filter.hasOwnProperty(val))
	rslt[val] = src[val];
	}
	return rslt;
	}

	/** @private Copy properties from src to result if a property of the same name exists in filter */
	static public function shallowCopyNotInFilter(src:Object,filter:Object):Object
	{
	// make a shallow copy
	var rslt:Object = new Object()
	for (var val:Object in src)
	{
	if (!filter.hasOwnProperty(val))
	rslt[val] = src[val];
	}
	return rslt;
	}

	static private function compareStylesLoop(o1:Object,o2:Object,description:Object):Boolean
	{
	for (var val:String in o1)
	{
	var o1val:Object = o1[val];
	var o2val:Object = o2[val];
	if (o1val != o2val)
	{
	if (!(o1val is Array) \|\| !(o2val is Array) \|\| o1val.length != o2val.length \|\| !description)
	return false; // different
	var prop:ArrayProperty = description[val];
	if (!prop \|\| !equalAllHelper(prop.memberType.tlf_internal::description,o1val,o2val))
	return false;
	}
	}
	return true;
	}
	/** @private */
	static tlf_internal const nullStyleObject:Object = new Object();
	/** @private */
	static public function equalStyles(o1:Object,o2:Object,description:Object):Boolean
	{
	if (o1 == null)
	o1 = nullStyleObject;
	if (o2 == null)
	o2 = nullStyleObject;
	// Use of prototype chains and bug https://bugzilla.mozilla.org/show_bug.cgi?id=447673 requires this two way compare
	return compareStylesLoop(o1,o2,description) && compareStylesLoop(o2,o1,description);
	}

	/** @private */
	static public function toNumberIfPercent(o:Object):Number
	{
	if (!(o is String))
	return NaN;
	var s:String = String(o);
	var len:int = s.length;

	return len != 0 && s.charAt(len-1) == "%" ? parseFloat(s) : NaN;
	}

	static private var prototypeFactory:Function = function():void
	{ }

	/** @private Create an object with specified prototype parent */
	static public function createObjectWithPrototype(parent:Object):Object
	{
	prototypeFactory.prototype = parent;
	return new prototypeFactory();
	}
	}
	}