Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
17381 lines (17381 sloc) 883 KB
<haxe>
<class path="Array" params="T" file="/usr/lib/haxe/std/Array.hx" extern="1">
<iterator public="1" set="method">
<f a=""><t path="Iterator"><c path="Array.T"/></t></f>
<haxe_doc>Returns an iterator of the Array values.</haxe_doc>
</iterator>
<copy public="1" set="method">
<f a=""><c path="Array"><c path="Array.T"/></c></f>
<haxe_doc>Returns a copy of the Array. The values are not
copied, only the Array structure.</haxe_doc>
</copy>
<remove public="1" set="method">
<f a="x">
<c path="Array.T"/>
<e path="Bool"/>
</f>
<haxe_doc>Removes the first occurence of [x].
Returns false if [x] was not present.
Elements are compared by using standard equality.</haxe_doc>
</remove>
<insert public="1" set="method">
<f a="pos:x">
<c path="Int"/>
<c path="Array.T"/>
<e path="Void"/>
</f>
<haxe_doc>Inserts the element [x] at the position [pos].
All elements after [pos] are moved one index ahead.</haxe_doc>
</insert>
<unshift public="1" set="method">
<f a="x">
<c path="Array.T"/>
<e path="Void"/>
</f>
<haxe_doc>Adds the element [x] at the start of the array.</haxe_doc>
</unshift>
<toString public="1" set="method">
<f a=""><c path="String"/></f>
<haxe_doc>Returns a displayable representation of the Array content.</haxe_doc>
</toString>
<splice public="1" set="method">
<f a="pos:len">
<c path="Int"/>
<c path="Int"/>
<c path="Array"><c path="Array.T"/></c>
</f>
<haxe_doc>Removes [len] elements starting from [pos] an returns them.</haxe_doc>
</splice>
<sort public="1" set="method">
<f a="f">
<f a=":">
<c path="Array.T"/>
<c path="Array.T"/>
<c path="Int"/>
</f>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[Sort the Array according to the comparison function [f].
[f(x,y)] should return [0] if [x == y], [>0] if [x > y]
and [<0] if [x < y].]]></haxe_doc>
</sort>
<slice public="1" set="method">
<f a="pos:?end">
<c path="Int"/>
<c path="Int"/>
<c path="Array"><c path="Array.T"/></c>
</f>
<haxe_doc>Copies the range of the array starting at [pos] up to,
but not including, [end]. Both [pos] and [end] can be
negative to count from the end: -1 is the last item in
the array.</haxe_doc>
</slice>
<shift public="1" set="method">
<f a=""><t path="Null"><c path="Array.T"/></t></f>
<haxe_doc>Removes the first element and returns it.</haxe_doc>
</shift>
<reverse public="1" set="method">
<f a=""><e path="Void"/></f>
<haxe_doc>Reverse the order of elements of the Array.</haxe_doc>
</reverse>
<push public="1" set="method">
<f a="x">
<c path="Array.T"/>
<c path="Int"/>
</f>
<haxe_doc>Adds the element [x] at the end of the array.</haxe_doc>
</push>
<pop public="1" set="method">
<f a=""><t path="Null"><c path="Array.T"/></t></f>
<haxe_doc>Removes the last element of the array and returns it.</haxe_doc>
</pop>
<join public="1" set="method">
<f a="sep">
<c path="String"/>
<c path="String"/>
</f>
<haxe_doc>Returns a representation of an array with [sep] for separating each element.</haxe_doc>
</join>
<concat public="1" set="method">
<f a="a">
<c path="Array"><c path="Array.T"/></c>
<c path="Array"><c path="Array.T"/></c>
</f>
<haxe_doc>Returns a new Array by appending [a] to [this].</haxe_doc>
</concat>
<length public="1" set="null">
<c path="Int"/>
<haxe_doc>The length of the Array</haxe_doc>
</length>
<new public="1" set="method">
<f a=""><e path="Void"/></f>
<haxe_doc>Creates a new Array.</haxe_doc>
</new>
<haxe_doc>An Array is a storage for values. You can access it using indexes or
with its API. On the server side, it's often better to use a [List] which
is less memory and CPU consuming, unless you really need indexed access.</haxe_doc>
</class>
<class path="Class" params="T" file="/usr/lib/haxe/std/Class.hx" extern="1"><haxe_doc>An abstract type that represents a Class.
See [Type] for the haXe Reflection API.</haxe_doc></class>
<class path="Hash" params="T" file="/usr/lib/haxe/std/cpp/_std/Hash.hx">
<toString public="1" set="method" line="76">
<f a=""><c path="String"/></f>
<haxe_doc>Returns an displayable representation of the hashtable content.</haxe_doc>
</toString>
<iterator public="1" set="method" line="61">
<f a=""><t path="Iterator"><c path="Hash.T"/></t></f>
<haxe_doc>Returns an iterator of all values in the hashtable.</haxe_doc>
</iterator>
<keys public="1" set="method" line="52">
<f a=""><t path="Iterator"><c path="String"/></t></f>
<haxe_doc>Returns an iterator of all keys in the hashtable.</haxe_doc>
</keys>
<remove public="1" set="method" line="45">
<f a="key">
<c path="String"/>
<e path="Bool"/>
</f>
<haxe_doc>Removes a hashtable entry. Returns [true] if
there was such entry.</haxe_doc>
</remove>
<exists public="1" set="method" line="41">
<f a="key">
<c path="String"/>
<e path="Bool"/>
</f>
<haxe_doc>Tells if a value exists for the given key.
In particular, it's useful to tells if a key has
a [null] value versus no value.</haxe_doc>
</exists>
<get public="1" set="method" line="37">
<f a="key">
<c path="String"/>
<t path="Null"><c path="Hash.T"/></t>
</f>
<haxe_doc>Get a value for the given key.</haxe_doc>
</get>
<set public="1" set="method" line="33">
<f a="key:value">
<c path="String"/>
<c path="Hash.T"/>
<e path="Void"/>
</f>
<haxe_doc>Set a value for the given key.</haxe_doc>
</set>
<__Internal><d/></__Internal>
<new public="1" set="method" line="29">
<f a=""><e path="Void"/></f>
<haxe_doc>Creates a new empty hashtable.</haxe_doc>
</new>
<haxe_doc>Hashtable over a set of elements, using [String] as keys.
Other kind of keys are not possible on all platforms since they
can't always be implemented efficiently.</haxe_doc>
<meta><m n=":core_api"/></meta>
</class>
<class path="IntHash" params="T" file="/usr/lib/haxe/std/cpp/_std/IntHash.hx">
<toString public="1" set="method" line="60">
<f a=""><c path="String"/></f>
<haxe_doc>Returns an displayable representation of the hashtable content.</haxe_doc>
</toString>
<iterator public="1" set="method" line="55">
<f a=""><t path="Iterator"><c path="IntHash.T"/></t></f>
<haxe_doc>Returns an iterator of all values in the hashtable.</haxe_doc>
</iterator>
<keys public="1" set="method" line="50">
<f a=""><t path="Iterator"><c path="Int"/></t></f>
<haxe_doc>Returns an iterator of all keys in the hashtable.</haxe_doc>
</keys>
<remove public="1" set="method" line="46">
<f a="key">
<c path="Int"/>
<e path="Bool"/>
</f>
<haxe_doc>Removes a hashtable entry. Returns [true] if
there was such entry.</haxe_doc>
</remove>
<exists public="1" set="method" line="42">
<f a="key">
<c path="Int"/>
<e path="Bool"/>
</f>
<haxe_doc>Tells if a value exists for the given key.
In particular, it's useful to tells if a key has
a [null] value versus no value.</haxe_doc>
</exists>
<get public="1" set="method" line="38">
<f a="key">
<c path="Int"/>
<t path="Null"><c path="IntHash.T"/></t>
</f>
<haxe_doc>Get a value for the given key.</haxe_doc>
</get>
<set public="1" set="method" line="34">
<f a="key:value">
<c path="Int"/>
<c path="IntHash.T"/>
<e path="Void"/>
</f>
<haxe_doc>Set a value for the given key.</haxe_doc>
</set>
<h><d/></h>
<new public="1" set="method" line="30">
<f a=""><e path="Void"/></f>
<haxe_doc>Creates a new empty hashtable.</haxe_doc>
</new>
<haxe_doc>Hashtable over a set of elements, using [Int] as keys.
On Flash and Javascript, the underlying structure is an Object.</haxe_doc>
<meta><m n=":core_api"/></meta>
</class>
<class path="Std" params="" file="/usr/lib/haxe/std/cpp/_std/Std.hx">
<is public="1" set="method" line="27" static="1">
<f a="v:t">
<d/>
<d/>
<e path="Bool"/>
</f>
<haxe_doc>Tells if a value v is of the type t.</haxe_doc>
</is>
<string public="1" set="method" line="31" static="1">
<f a="s">
<d/>
<c path="String"/>
</f>
<haxe_doc>Convert any value to a String</haxe_doc>
</string>
<int public="1" set="method" line="35" static="1">
<f a="x">
<c path="Float"/>
<c path="Int"/>
</f>
<haxe_doc>Convert a Float to an Int, rounded down.</haxe_doc>
</int>
<parseInt public="1" set="method" line="39" static="1">
<f a="x">
<c path="String"/>
<t path="Null"><c path="Int"/></t>
</f>
<haxe_doc>Convert a String to an Int, parsing different possible representations. Returns [null] if could not be parsed.</haxe_doc>
</parseInt>
<parseFloat public="1" set="method" line="43" static="1">
<f a="x">
<c path="String"/>
<c path="Float"/>
</f>
<haxe_doc>Convert a String to a Float, parsing different possible reprensations.</haxe_doc>
</parseFloat>
<random public="1" set="method" line="47" static="1">
<f a="x">
<c path="Int"/>
<c path="Int"/>
</f>
<haxe_doc>Return a random integer between 0 included and x excluded.</haxe_doc>
</random>
<haxe_doc>The Std class provides standard methods for manipulating basic types.</haxe_doc>
<meta><m n=":core_api"/></meta>
</class>
<enum path="Void" params="" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes"><haxe_doc>The standard Void type. Only [null] values can be of the type [Void].</haxe_doc></enum>
<class path="Float" params="" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes" extern="1"><haxe_doc>The standard Float type, this is a double-precision IEEE 64bit float.</haxe_doc></class>
<class path="Int" params="" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes" extern="1">
<extends path="Float"/>
<haxe_doc>The standard Int type. Its precision depends on the platform.</haxe_doc>
</class>
<typedef path="Null" params="T" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes">
<c path="Null.T"/>
<haxe_doc>[Null] can be useful in two cases. In order to document some methods
that accepts or can return a [null] value, or for the Flash9 compiler and AS3
generator to distinguish between base values that can be null and others that
can't.</haxe_doc>
</typedef>
<enum path="Bool" params="" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes">
<true/>
<false/>
<haxe_doc>The standard Boolean type is represented as an enum with two choices.</haxe_doc>
</enum>
<class path="Dynamic" params="T" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes" extern="1"><haxe_doc>Dynamic is an internal compiler type which has special behavior.
See the haXe language reference for more informations.</haxe_doc></class>
<typedef path="Iterator" params="T" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes">
<a>
<next set="method"><f a=""><c path="Iterator.T"/></f></next>
<hasNext set="method"><f a=""><e path="Bool"/></f></hasNext>
</a>
<haxe_doc>An Iterator is a structure that permits to list a given container
values. It can be used by your own data structures. See the haXe
documentation for more informations.</haxe_doc>
</typedef>
<typedef path="Iterable" params="T" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes">
<a><iterator set="method"><f a=""><t path="Iterator"><c path="Iterable.T"/></t></f></iterator></a>
<haxe_doc>An Iterable is a data structure which has an iterator() method.
See [Lambda] for generic functions on iterable structures.</haxe_doc>
</typedef>
<class path="ArrayAccess" params="T" file="/usr/lib/haxe/std/StdTypes.hx" module="StdTypes" extern="1" interface="1"><haxe_doc>ArrayAccess is used to indicate a class that can be accessed using brackets.
The type parameter represent the type of the elements stored.</haxe_doc></class>
<class path="String" params="" file="/usr/lib/haxe/std/String.hx" extern="1">
<fromCharCode public="1" set="method" static="1"><f a="code">
<c path="Int"/>
<c path="String"/>
</f></fromCharCode>
<toString public="1" set="method">
<f a=""><c path="String"/></f>
<haxe_doc>Returns the String itself.</haxe_doc>
</toString>
<substring public="1" set="method">
<f a="startIndex:?endIndex">
<c path="Int"/>
<c path="Int"/>
<c path="String"/>
</f>
<haxe_doc><![CDATA[Returns a part of the String, taking from [startIndex] to [endIndex] - 1.
If [endIndex] is not specified, length is used.
If [startIndex] or [endIndex] is smaller than 0, than 0 is used.
If [startIndex] > [endIndex] then they are swaped.]]></haxe_doc>
</substring>
<substr public="1" set="method">
<f a="pos:?len">
<c path="Int"/>
<c path="Int"/>
<c path="String"/>
</f>
<haxe_doc>Returns a part of the String, taking [len] characters starting from [pos].
If [len] is not specified, it takes all the remaining characters.</haxe_doc>
</substr>
<split public="1" set="method">
<f a="delimiter">
<c path="String"/>
<c path="Array"><c path="String"/></c>
</f>
<haxe_doc>Split the string using the specified delimiter.</haxe_doc>
</split>
<lastIndexOf public="1" set="method">
<f a="str:?startIndex">
<c path="String"/>
<c path="Int"/>
<c path="Int"/>
</f>
<haxe_doc>Similar to [indexOf] but returns the latest index.</haxe_doc>
</lastIndexOf>
<indexOf public="1" set="method">
<f a="str:?startIndex">
<c path="String"/>
<c path="Int"/>
<c path="Int"/>
</f>
<haxe_doc>Returns the index of first occurence of [value]
Returns [1-1] if [value] is not found.
The optional [startIndex] parameter allows you to specify at which character to start searching.
The position returned is still relative to the beginning of the string.</haxe_doc>
</indexOf>
<charCodeAt public="1" set="method">
<f a="index">
<c path="Int"/>
<t path="Null"><c path="Int"/></t>
</f>
<haxe_doc>Returns the character code at the given position.
Returns [null] if outside of String bounds.</haxe_doc>
</charCodeAt>
<charAt public="1" set="method">
<f a="index">
<c path="Int"/>
<c path="String"/>
</f>
<haxe_doc>Returns the character at the given position.
Returns the empty String if outside of String bounds.</haxe_doc>
</charAt>
<toLowerCase public="1" set="method">
<f a=""><c path="String"/></f>
<haxe_doc>Returns an String where all characters have been lowercased.</haxe_doc>
</toLowerCase>
<toUpperCase public="1" set="method">
<f a=""><c path="String"/></f>
<haxe_doc>Returns an String where all characters have been uppercased.</haxe_doc>
</toUpperCase>
<length public="1" set="null">
<c path="Int"/>
<haxe_doc>The number of characters in the String.</haxe_doc>
</length>
<new public="1" set="method">
<f a="string">
<c path="String"/>
<e path="Void"/>
</f>
<haxe_doc>Creates a copy from a given String.</haxe_doc>
</new>
<haxe_doc>The basic String class.</haxe_doc>
</class>
<class path="StringBuf" params="" file="/usr/lib/haxe/std/cpp/_std/StringBuf.hx">
<toString public="1" get="inline" set="null" line="47">
<f a=""><c path="String"/></f>
<haxe_doc>Returns the content of the string buffer.
The buffer is not emptied by this operation.</haxe_doc>
</toString>
<addChar public="1" get="inline" set="null" line="43">
<f a="c">
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc>Adds a part of a string to the string buffer.</haxe_doc>
</addChar>
<addSub public="1" get="inline" set="null" line="39">
<f a="s:pos:?len">
<c path="String"/>
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc>Adds a character to the string buffer.</haxe_doc>
</addSub>
<add public="1" get="inline" set="null" line="35">
<f a="x">
<d/>
<e path="Void"/>
</f>
<haxe_doc>Adds the representation of any value to the string buffer.</haxe_doc>
</add>
<b><c path="Array"><d/></c></b>
<new public="1" set="method" line="31">
<f a=""><e path="Void"/></f>
<haxe_doc>Creates a new string buffer.</haxe_doc>
</new>
<haxe_doc>A String buffer is an efficient way to build a big string by
appending small elements together.</haxe_doc>
<meta><m n=":core_api"/></meta>
</class>
<class path="haxe.Log" params="" file="/usr/lib/haxe/std/haxe/Log.hx">
<trace public="1" set="dynamic" line="29" static="1"><f a="v:?infos">
<d/>
<t path="haxe.PosInfos"/>
<e path="Void"/>
</f></trace>
<clear public="1" set="dynamic" line="54" static="1"><f a=""><e path="Void"/></f></clear>
</class>
<typedef path="haxe.PosInfos" params="" file="/usr/lib/haxe/std/haxe/PosInfos.hx"><a>
<methodName><c path="String"/></methodName>
<lineNumber><c path="Int"/></lineNumber>
<fileName><c path="String"/></fileName>
<customParams>
<c path="Array"><d/></c>
<meta><m n=":optional"/></meta>
</customParams>
<className><c path="String"/></className>
</a></typedef>
<typedef path="haxe.TimerList" params="" file="/Users/joshua/Development/Haxe/nme/haxe/Timer.hx" module="haxe.Timer"><c path="Array"><c path="haxe.Timer"/></c></typedef>
<class path="nme.Loader" params="" file="/Users/joshua/Development/Haxe/nme/nme/Loader.hx" extern="1">
<load public="1" set="method" static="1"><f a="func:args">
<c path="String"/>
<c path="Int"/>
<d/>
</f></load>
<loaderTrace public="1" set="method" static="1"><f a="inStr">
<c path="String"/>
<e path="Void"/>
</f></loaderTrace>
<tryLoad public="1" set="method" static="1"><f a="inName:func:args">
<c path="String"/>
<c path="String"/>
<c path="Int"/>
<d/>
</f></tryLoad>
</class>
<class path="haxe.Timer" params="" file="/Users/joshua/Development/Haxe/nme/haxe/Timer.hx">
<sRunningTimers line="106" static="1"><t path="haxe.TimerList"/></sRunningTimers>
<measure public="1" params="T" set="method" line="123" static="1"><f a="f:?pos">
<f a=""><c path="measure.T"/></f>
<t path="haxe.PosInfos"/>
<c path="measure.T"/>
</f></measure>
<nmeNextWake public="1" set="method" line="154" static="1">
<f a="limit">
<c path="Float"/>
<c path="Float"/>
</f>
<haxe_doc>* @private</haxe_doc>
</nmeNextWake>
<nmeCheckTimers public="1" set="method" line="196" static="1">
<f a=""><e path="Void"/></f>
<haxe_doc>* @private</haxe_doc>
</nmeCheckTimers>
<GetMS set="method" line="209" static="1"><f a=""><c path="Float"/></f></GetMS>
<delay public="1" set="method" line="217" static="1"><f a="f:time">
<f a=""><e path="Void"/></f>
<c path="Int"/>
<c path="haxe.Timer"/>
</f></delay>
<stamp public="1" set="method" line="231" static="1"><f a=""><c path="Float"/></f></stamp>
<nme_time_stamp line="238" static="1"><f a=""><c path="Float"/></f></nme_time_stamp>
<nmeCheck set="method" line="181"><f a="inTime">
<c path="Float"/>
<e path="Void"/>
</f></nmeCheck>
<stop public="1" set="method" line="139"><f a=""><e path="Void"/></f></stop>
<run public="1" set="dynamic" line="132"><f a=""><e path="Void"/></f></run>
<mRunning><e path="Bool"/></mRunning>
<mFireAt><c path="Float"/></mFireAt>
<mTime><c path="Float"/></mTime>
<new public="1" set="method" line="113"><f a="time">
<c path="Float"/>
<e path="Void"/>
</f></new>
</class>
<class path="nme.Assets" params="" file="/Users/joshua/Development/Haxe/nme/nme/Assets.hx">
<cachedBitmapData public="1" line="32" static="1"><c path="Hash"><c path="nme.display.BitmapData"/></c></cachedBitmapData>
<getBitmapData public="1" set="method" line="42" static="1">
<f a="id:?useCache">
<c path="String"/>
<e path="Bool"/>
<c path="nme.display.BitmapData"/>
</f>
<haxe_doc>* Gets an instance of an embedded bitmap
* @usage var bitmap = new Bitmap (Assets.getBitmapData ("image.jpg"));
* @param id The ID or asset path for the bitmap
* @param useCache (Optional) Whether to use BitmapData from the cache (Default: true)
* @return A new BItmapData object</haxe_doc>
</getBitmapData>
<getBytes public="1" set="method" line="54" static="1">
<f a="id">
<c path="String"/>
<c path="nme.utils.ByteArray"/>
</f>
<haxe_doc>* Gets an instance of an embedded binary asset
* @usage var bytes = Assets.getBytes ("file.zip");
* @param id The ID or asset path for the file
* @return A new ByteArray object</haxe_doc>
</getBytes>
<getFont public="1" set="method" line="66" static="1">
<f a="id">
<c path="String"/>
<c path="nme.text.Font"/>
</f>
<haxe_doc>* Gets an instance of an embedded font
* @usage var fontName = Assets.getFont ("font.ttf").fontName;
* @param id The ID or asset path for the font
* @return A new Font object</haxe_doc>
</getFont>
<getSound public="1" set="method" line="78" static="1">
<f a="id">
<c path="String"/>
<c path="nme.media.Sound"/>
</f>
<haxe_doc>* Gets an instance of an embedded sound
* @usage var sound = Assets.getSound ("sound.wav");
* @param id The ID or asset path for the sound
* @return A new Sound object</haxe_doc>
</getSound>
<getText public="1" set="method" line="90" static="1">
<f a="id">
<c path="String"/>
<c path="String"/>
</f>
<haxe_doc>* Gets an instance of an embedded text asset
* @usage var text = Assets.getText ("text.txt");
* @param id The ID or asset path for the file
* @return A new String object</haxe_doc>
</getText>
<haxe_doc><![CDATA[* <p>The Assets class provides a cross-platform interface to access
* embedded images, fonts, sounds and other resource files.</p>
*
* <p>The contents are populated automatically when an application
* is compiled using the NME command-line tools, based on the
* contents of the *.nmml project file.</p>
*
* <p>For most platforms, the assets are included in the same directory
* or package as the application, and the paths are handled
* automatically. For web content, the assets are preloaded before
* the start of the rest of the application. You can customize the
* preloader by extending the <code>NMEPreloader</code> class,
* and specifying a custom preloader using <window preloader="" />
* in the project file.</p>
*
* @author Joshua Granick]]></haxe_doc>
</class>
<class path="nme.JNI" params="" file="/Users/joshua/Development/Haxe/nme/nme/JNI.hx" extern="1">
<createMemberMethod public="1" set="method" static="1">
<f a="className:memberName:signature:?useArray">
<c path="String"/>
<c path="String"/>
<c path="String"/>
<e path="Bool"/>
<d/>
</f>
<haxe_doc>* Create bindings to an class instance method in Java
* @param className The name of the target class in Java
* @param memberName The name of the target method
* @param signature The JNI string-based type signature for the method
* @param useArray Whether the method should accept multiple parameters, or a single array with the parameters to pass to Java
* @return A method that calls Java. The first parameter is a handle for the Java object instance, the rest are passed into the method as arguments</haxe_doc>
</createMemberMethod>
<createStaticMethod public="1" set="method" static="1">
<f a="className:memberName:signature:?useArray">
<c path="String"/>
<c path="String"/>
<c path="String"/>
<e path="Bool"/>
<d/>
</f>
<haxe_doc>* Create bindings to a static class method in Java
* @param className The name of the target class in Java
* @param memberName The name of the target method
* @param signature The JNI string-based type signature for the method
* @param useArray Whether the method should accept multiple parameters, or a single array with the parameters to pass to Java
* @return A method that calls Java. Each argument is passed into the Java method as arguments</haxe_doc>
</createStaticMethod>
</class>
<class path="nme.Lib" params="" file="/Users/joshua/Development/Haxe/nme/nme/Lib.hx">
<FULLSCREEN public="1" line="13" static="1"><c path="Int"/></FULLSCREEN>
<BORDERLESS public="1" line="14" static="1"><c path="Int"/></BORDERLESS>
<RESIZABLE public="1" line="15" static="1"><c path="Int"/></RESIZABLE>
<HARDWARE public="1" line="16" static="1"><c path="Int"/></HARDWARE>
<VSYNC public="1" line="17" static="1"><c path="Int"/></VSYNC>
<HW_AA public="1" line="18" static="1"><c path="Int"/></HW_AA>
<HW_AA_HIRES public="1" line="19" static="1"><c path="Int"/></HW_AA_HIRES>
<ALLOW_SHADERS public="1" line="20" static="1"><c path="Int"/></ALLOW_SHADERS>
<company public="1" get="nmeGetCompany" set="null" static="1"><c path="String"/></company>
<current public="1" get="nmeGetCurrent" set="null" static="1"><c path="nme.display.MovieClip"/></current>
<file public="1" get="nmeGetFile" set="null" static="1"><c path="String"/></file>
<initHeight public="1" get="nmeGetInitHeight" set="null" static="1"><c path="Int"/></initHeight>
<initWidth public="1" get="nmeGetInitWidth" set="null" static="1"><c path="Int"/></initWidth>
<packageName public="1" get="nmeGetPackageName" set="null" static="1"><c path="String"/></packageName>
<stage public="1" get="nmeGetStage" set="null" static="1"><c path="nme.display.Stage"/></stage>
<version public="1" get="nmeGetVersion" set="null" static="1"><c path="String"/></version>
<close public="1" set="method" line="36" static="1">
<f a=""><e path="Void"/></f>
<haxe_doc>* Closes the application.
* This is method is ignored in the Flash and HTML5 targets.</haxe_doc>
</close>
<create public="1" set="method" line="59" static="1">
<f a="onLoaded:width:height:?frameRate:?color:?flags:?title:?icon">
<f a=""><e path="Void"/></f>
<c path="Int"/>
<c path="Int"/>
<c path="Float"/>
<c path="Int"/>
<c path="Int"/>
<c path="String"/>
<c path="nme.display.BitmapData"/>
<e path="Void"/>
</f>
<haxe_doc>* Creates a new application window. If you are using the NME
* command-line tools, this method will be called automatically
* as a part of the default platform templates.
* This is method is ignored in the Flash and HTML5 targets.
* @param onLoaded A method callback that is called once the window is created.
* @param width The requested width of the window. Use a width and height of 0 to request the full screen size.
* @param height The requested height of the window. Use a width and height of 0 to request the full screen size.
* @param frameRate The requested frame rate for the application.
* @param color An RGB color to use for the application background.
* @param flags A series of bit flags which can specify windowing options, like FULLSCREEN or HARDWARE
* @param title The title to use when creating the application window.
* @param icon An icon to use for the created application window.</haxe_doc>
</create>
<createManagedStage public="1" set="method" line="75" static="1">
<f a="width:height">
<c path="Int"/>
<c path="Int"/>
<unknown/>
</f>
<haxe_doc>* Creates a managed stage, for greater control customization and control
* of application events.
* This method is ignored in the Flash and HTML5 targets.
* @param width The requested width of the managed stage.
* @param height The requested width of the managed stage.</haxe_doc>
</createManagedStage>
<exit public="1" set="method" line="91" static="1">
<f a=""><e path="Void"/></f>
<haxe_doc><![CDATA[* Similar to the <code>close()</code> method, but the current
* <code>Stage</code> object is given an opportunity to handle
* the quit event before the application process is ended.
* This method is ignored in the Flash and HTML5 targets.]]></haxe_doc>
</exit>
<forceClose public="1" set="method" line="105" static="1">
<f a=""><e path="Void"/></f>
<haxe_doc>* Terminates the application process immediately without
* performing a clean shutdown.
* This method is ignored in the Flash and HTML5 targets.</haxe_doc>
</forceClose>
<getTimer public="1" get="inline" set="null" line="123" static="1">
<f a=""><c path="Int"/></f>
<haxe_doc><![CDATA[* Returns the time in milliseconds, relative to the start of
* the application. This is a high performance call in order to
* help regulate time-based operations. Depending upon the
* target platform, this value may or may not be an absolute
* timestamp. If you need an exact time, you should use the
* <code>Date</code> object.
* @return A relative time value in milliseconds.]]></haxe_doc>
</getTimer>
<getURL public="1" set="method" line="142" static="1">
<f a="url:?target">
<c path="nme.net.URLRequest"/>
<c path="String"/>
<e path="Void"/>
</f>
<haxe_doc>* Opens a browser window with the specified URL.
* @param url The URL to open.
* @param target An optional window target value.</haxe_doc>
</getURL>
<pause public="1" set="method" line="161" static="1">
<f a=""><e path="Void"/></f>
<haxe_doc>* For supported platforms, the NME application will be
* paused. This can help improve response times if fullscreen
* native UI element is being used temporarily.
* This method is ignored in the Flash and HTML5 targets.</haxe_doc>
</pause>
<postUICallback public="1" set="method" line="179" static="1">
<f a="handler">
<f a=""><e path="Void"/></f>
<e path="Void"/>
</f>
<haxe_doc>* For some target platforms, NME operates on a separate thread
* than the native application UI. In these cases, you can use this
* method to make thread-safe calls to the native UI.
*
* If the platform does not require thread-safe callbacks, the
* handler method will be called immediately.
* @param handler The method handler you wish to call when the UI is available.</haxe_doc>
</postUICallback>
<resume public="1" set="method" line="196" static="1">
<f a=""><e path="Void"/></f>
<haxe_doc>* Resumes the NME application. For certain platforms,
* pausing the application can improve response times when
* a fullscreen native UI element is being displayed.
* This method is ignored in the Flash and HTML5 targets.</haxe_doc>
</resume>
<setPackage public="1" set="method" line="215" static="1">
<f a="company:file:packageName:version">
<c path="String"/>
<c path="String"/>
<c path="String"/>
<c path="String"/>
<e path="Void"/>
</f>
<haxe_doc>* Specifies meta-data for the running application. If you are using
* the NME command-line tools, this method will be called automatically
* as a part of the default platform templates.
* This method is ignored in the Flash and HTML5 targets.
* @param company The company name for the application.
* @param file The file name for the application.
* @param packageName The package name of the application.
* @param version The version string of the application.</haxe_doc>
</setPackage>
<trace public="1" set="method" line="228" static="1">
<f a="arg">
<d/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Sends a <code>trace</code> call for the current platform.
* @param arg]]></haxe_doc>
</trace>
<nmeGetCompany set="method" line="247" static="1"><f a=""><c path="String"/></f></nmeGetCompany>
<nmeGetCurrent set="method" line="257" static="1"><f a=""><c path="nme.display.MovieClip"/></f></nmeGetCurrent>
<nmeGetFile set="method" line="271" static="1"><f a=""><c path="String"/></f></nmeGetFile>
<nmeGetInitHeight set="method" line="281" static="1"><f a=""><c path="Int"/></f></nmeGetInitHeight>
<nmeGetInitWidth set="method" line="291" static="1"><f a=""><c path="Int"/></f></nmeGetInitWidth>
<nmeGetPackageName set="method" line="301" static="1"><f a=""><c path="String"/></f></nmeGetPackageName>
<nmeGetStage set="method" line="311" static="1"><f a=""><c path="nme.display.Stage"/></f></nmeGetStage>
<nmeGetVersion set="method" line="323" static="1"><f a=""><c path="String"/></f></nmeGetVersion>
</class>
<class path="nme.Memory" params="" file="/Users/joshua/Development/Haxe/nme/nme/Memory.hx" extern="1">
<select public="1" set="method" static="1"><f a="inBytes">
<c path="nme.utils.ByteArray"/>
<e path="Void"/>
</f></select>
<getByte public="1" set="method" static="1"><f a="addr">
<c path="Int"/>
<c path="Int"/>
</f></getByte>
<getDouble public="1" set="method" static="1"><f a="addr">
<c path="Int"/>
<c path="Float"/>
</f></getDouble>
<getFloat public="1" set="method" static="1"><f a="addr">
<c path="Int"/>
<c path="Float"/>
</f></getFloat>
<getI32 public="1" set="method" static="1"><f a="addr">
<c path="Int"/>
<c path="Int"/>
</f></getI32>
<getUI16 public="1" set="method" static="1"><f a="addr">
<c path="Int"/>
<c path="Int"/>
</f></getUI16>
<setByte public="1" set="method" static="1"><f a="addr:v">
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f></setByte>
<setDouble public="1" set="method" static="1"><f a="addr:v">
<c path="Int"/>
<c path="Float"/>
<e path="Void"/>
</f></setDouble>
<setFloat public="1" set="method" static="1"><f a="addr:v">
<c path="Int"/>
<c path="Float"/>
<e path="Void"/>
</f></setFloat>
<setI16 public="1" set="method" static="1"><f a="addr:v">
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f></setI16>
<setI32 public="1" set="method" static="1"><f a="addr:v">
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f></setI32>
</class>
<class path="nme.ObjectHash" params="K:T" file="/Users/joshua/Development/Haxe/nme/nme/ObjectHash.hx">
<nextObjectID line="19" static="1">
<c path="Int"/>
<haxe_doc>@private</haxe_doc>
</nextObjectID>
<set public="1" get="inline" set="null" line="155"><f a="key:value">
<c path="nme.ObjectHash.K"/>
<c path="nme.ObjectHash.T"/>
<e path="Void"/>
</f></set>
<remove public="1" get="inline" set="null" line="137"><f a="key">
<c path="nme.ObjectHash.K"/>
<e path="Void"/>
</f></remove>
<keys public="1" get="inline" set="null" line="122"><f a=""><t path="Iterator"><c path="nme.ObjectHash.K"/></t></f></keys>
<iterator public="1" get="inline" set="null" line="99"><f a=""><t path="Iterator"><c path="nme.ObjectHash.T"/></t></f></iterator>
<getID get="inline" set="null" line="68">
<f a="key">
<c path="nme.ObjectHash.K"/>
<c path="Int"/>
</f>
<haxe_doc>@private</haxe_doc>
</getID>
<get public="1" get="inline" set="null" line="53"><f a="key">
<c path="nme.ObjectHash.K"/>
<c path="nme.ObjectHash.T"/>
</f></get>
<exists public="1" get="inline" set="null" line="38"><f a="key">
<c path="nme.ObjectHash.K"/>
<e path="Bool"/>
</f></exists>
<hashValues>
<c path="IntHash"><c path="nme.ObjectHash.T"/></c>
<haxe_doc>@private</haxe_doc>
</hashValues>
<hashKeys>
<c path="IntHash"><c path="nme.ObjectHash.K"/></c>
<haxe_doc>@private</haxe_doc>
</hashKeys>
<new public="1" set="method" line="22"><f a=""><e path="Void"/></f></new>
</class>
<typedef path="nme.Vector" params="T" file="/Users/joshua/Development/Haxe/nme/nme/Vector.hx"><c path="Array"><c path="nme.Vector.T"/></c></typedef>
<class path="nme.VectorHelper" params="" file="/Users/joshua/Development/Haxe/nme/nme/Vector.hx" module="nme.Vector"><ofArray public="1" params="T" get="inline" set="null" line="12" static="1"><f a="v:array">
<c path="Class"><t path="nme.Vector"><d/></t></c>
<c path="Array"><c path="ofArray.T"/></c>
<t path="nme.Vector"><c path="ofArray.T"/></t>
</f></ofArray></class>
<class path="nme.events.IEventDispatcher" params="" file="/Users/joshua/Development/Haxe/nme/nme/events/IEventDispatcher.hx" extern="1" interface="1">
<willTrigger public="1" set="method"><f a="type">
<c path="String"/>
<e path="Bool"/>
</f></willTrigger>
<removeEventListener public="1" set="method"><f a="type:listener:?useCapture">
<c path="String"/>
<f a="">
<d/>
<e path="Void"/>
</f>
<e path="Bool"/>
<e path="Void"/>
</f></removeEventListener>
<hasEventListener public="1" set="method"><f a="type">
<c path="String"/>
<e path="Bool"/>
</f></hasEventListener>
<dispatchEvent public="1" set="method"><f a="event">
<c path="nme.events.Event"/>
<e path="Bool"/>
</f></dispatchEvent>
<addEventListener public="1" set="method"><f a="type:listener:?useCapture:?priority:?useWeakReference">
<c path="String"/>
<f a="">
<d/>
<e path="Void"/>
</f>
<e path="Bool"/>
<c path="Int"/>
<e path="Bool"/>
<e path="Void"/>
</f></addEventListener>
</class>
<class path="nme.events.EventDispatcher" params="" file="/Users/joshua/Development/Haxe/nme/nme/events/EventDispatcher.hx" extern="1">
<implements path="nme.events.IEventDispatcher"/>
<willTrigger public="1" set="method">
<f a="type">
<c path="String"/>
<e path="Bool"/>
</f>
<haxe_doc><![CDATA[* Checks whether an event listener is registered with this EventDispatcher
* object or any of its ancestors for the specified event type. This method
* returns <code>true</code> if an event listener is triggered during any
* phase of the event flow when an event of the specified type is dispatched
* to this EventDispatcher object or any of its descendants.
*
* <p>The difference between the <code>hasEventListener()</code> and the
* <code>willTrigger()</code> methods is that <code>hasEventListener()</code>
* examines only the object to which it belongs, whereas the
* <code>willTrigger()</code> method examines the entire event flow for the
* event specified by the <code>type</code> parameter. </p>
*
* <p>When <code>willTrigger()</code> is called from a LoaderInfo object,
* only the listeners that the caller can access are considered.</p>
*
* @param type The type of event.
* @return A value of <code>true</code> if a listener of the specified type
* will be triggered; <code>false</code> otherwise.]]></haxe_doc>
</willTrigger>
<toString public="1" set="method"><f a=""><c path="String"/></f></toString>
<removeEventListener public="1" set="method">
<f a="type:listener:?useCapture">
<c path="String"/>
<f a="">
<d/>
<e path="Void"/>
</f>
<e path="Bool"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Removes a listener from the EventDispatcher object. If there is no
* matching listener registered with the EventDispatcher object, a call to
* this method has no effect.
*
* @param type The type of event.
* @param useCapture Specifies whether the listener was registered for the
* capture phase or the target and bubbling phases. If the
* listener was registered for both the capture phase and
* the target and bubbling phases, two calls to
* <code>removeEventListener()</code> are required to
* remove both, one call with <code>useCapture()</code> set
* to <code>true</code>, and another call with
* <code>useCapture()</code> set to <code>false</code>.]]></haxe_doc>
</removeEventListener>
<hasEventListener public="1" set="method">
<f a="type">
<c path="String"/>
<e path="Bool"/>
</f>
<haxe_doc><![CDATA[* Checks whether the EventDispatcher object has any listeners registered for
* a specific type of event. This allows you to determine where an
* EventDispatcher object has altered handling of an event type in the event
* flow hierarchy. To determine whether a specific event type actually
* triggers an event listener, use <code>willTrigger()</code>.
*
* <p>The difference between <code>hasEventListener()</code> and
* <code>willTrigger()</code> is that <code>hasEventListener()</code>
* examines only the object to which it belongs, whereas
* <code>willTrigger()</code> examines the entire event flow for the event
* specified by the <code>type</code> parameter. </p>
*
* <p>When <code>hasEventListener()</code> is called from a LoaderInfo
* object, only the listeners that the caller can access are considered.</p>
*
* @param type The type of event.
* @return A value of <code>true</code> if a listener of the specified type
* is registered; <code>false</code> otherwise.]]></haxe_doc>
</hasEventListener>
<dispatchEvent public="1" set="method">
<f a="event">
<c path="nme.events.Event"/>
<e path="Bool"/>
</f>
<haxe_doc><![CDATA[* Dispatches an event into the event flow. The event target is the
* EventDispatcher object upon which the <code>dispatchEvent()</code> method
* is called.
*
* @param event The Event object that is dispatched into the event flow. If
* the event is being redispatched, a clone of the event is
* created automatically. After an event is dispatched, its
* <code>target</code> property cannot be changed, so you must
* create a new copy of the event for redispatching to work.
* @return A value of <code>true</code> if the event was successfully
* dispatched. A value of <code>false</code> indicates failure or
* that <code>preventDefault()</code> was called on the event.
* @throws Error The event dispatch recursion limit has been reached.]]></haxe_doc>
</dispatchEvent>
<addEventListener public="1" set="method">
<f a="type:listener:?useCapture:?priority:?useWeakReference">
<c path="String"/>
<f a="">
<d/>
<e path="Void"/>
</f>
<e path="Bool"/>
<c path="Int"/>
<e path="Bool"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Registers an event listener object with an EventDispatcher object so that
* the listener receives notification of an event. You can register event
* listeners on all nodes in the display list for a specific type of event,
* phase, and priority.
*
* <p>After you successfully register an event listener, you cannot change
* its priority through additional calls to <code>addEventListener()</code>.
* To change a listener's priority, you must first call
* <code>removeListener()</code>. Then you can register the listener again
* with the new priority level. </p>
*
* <p>Keep in mind that after the listener is registered, subsequent calls to
* <code>addEventListener()</code> with a different <code>type</code> or
* <code>useCapture</code> value result in the creation of a separate
* listener registration. For example, if you first register a listener with
* <code>useCapture</code> set to <code>true</code>, it listens only during
* the capture phase. If you call <code>addEventListener()</code> again using
* the same listener object, but with <code>useCapture</code> set to
* <code>false</code>, you have two separate listeners: one that listens
* during the capture phase and another that listens during the target and
* bubbling phases. </p>
*
* <p>You cannot register an event listener for only the target phase or the
* bubbling phase. Those phases are coupled during registration because
* bubbling applies only to the ancestors of the target node.</p>
*
* <p>If you no longer need an event listener, remove it by calling
* <code>removeEventListener()</code>, or memory problems could result. Event
* listeners are not automatically removed from memory because the garbage
* collector does not remove the listener as long as the dispatching object
* exists (unless the <code>useWeakReference</code> parameter is set to
* <code>true</code>).</p>
*
* <p>Copying an EventDispatcher instance does not copy the event listeners
* attached to it. (If your newly created node needs an event listener, you
* must attach the listener after creating the node.) However, if you move an
* EventDispatcher instance, the event listeners attached to it move along
* with it.</p>
*
* <p>If the event listener is being registered on a node while an event is
* being processed on this node, the event listener is not triggered during
* the current phase but can be triggered during a later phase in the event
* flow, such as the bubbling phase.</p>
*
* <p>If an event listener is removed from a node while an event is being
* processed on the node, it is still triggered by the current actions. After
* it is removed, the event listener is never invoked again (unless
* registered again for future processing). </p>
*
* @param type The type of event.
* @param useCapture Determines whether the listener works in the
* capture phase or the target and bubbling phases.
* If <code>useCapture</code> is set to
* <code>true</code>, the listener processes the
* event only during the capture phase and not in the
* target or bubbling phase. If
* <code>useCapture</code> is <code>false</code>, the
* listener processes the event only during the
* target or bubbling phase. To listen for the event
* in all three phases, call
* <code>addEventListener</code> twice, once with
* <code>useCapture</code> set to <code>true</code>,
* then again with <code>useCapture</code> set to
* <code>false</code>.
* @param priority The priority level of the event listener. The
* priority is designated by a signed 32-bit integer.
* The higher the number, the higher the priority.
* All listeners with priority <i>n</i> are processed
* before listeners of priority <i>n</i>-1. If two or
* more listeners share the same priority, they are
* processed in the order in which they were added.
* The default priority is 0.
* @param useWeakReference Determines whether the reference to the listener
* is strong or weak. A strong reference (the
* default) prevents your listener from being
* garbage-collected. A weak reference does not.
*
* <p>Class-level member functions are not subject to
* garbage collection, so you can set
* <code>useWeakReference</code> to <code>true</code>
* for class-level member functions without
* subjecting them to garbage collection. If you set
* <code>useWeakReference</code> to <code>true</code>
* for a listener that is a nested inner function,
* the function will be garbage-collected and no
* longer persistent. If you create references to the
* inner function (save it in another variable) then
* it is not garbage-collected and stays
* persistent.</p>
* @throws ArgumentError The <code>listener</code> specified is not a
* function.]]></haxe_doc>
</addEventListener>
<new public="1" set="method">
<f a="?target">
<c path="nme.events.IEventDispatcher"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Aggregates an instance of the EventDispatcher class.
*
* <p>The EventDispatcher class is generally used as a base class, which
* means that most developers do not need to use this constructor function.
* However, advanced developers who are implementing the IEventDispatcher
* interface need to use this constructor. If you are unable to extend the
* EventDispatcher class and must instead implement the IEventDispatcher
* interface, use this constructor to aggregate an instance of the
* EventDispatcher class.</p>
*
* @param target The target object for events dispatched to the
* EventDispatcher object. This parameter is used when the
* EventDispatcher instance is aggregated by a class that
* implements IEventDispatcher; it is necessary so that the
* containing object can be the target for events. Do not use
* this parameter in simple cases in which a class extends
* EventDispatcher.]]></haxe_doc>
</new>
<haxe_doc><![CDATA[* The EventDispatcher class is the base class for all classes that dispatch
* events. The EventDispatcher class implements the IEventDispatcher interface
* and is the base class for the DisplayObject class. The EventDispatcher
* class allows any object on the display list to be an event target and as
* such, to use the methods of the IEventDispatcher interface.
*
* <p>Event targets are an important part of the Flash<sup>®</sup> Player and
* Adobe<sup>®</sup> AIR<sup>®</sup> event model. The event target serves as
* the focal point for how events flow through the display list hierarchy.
* When an event such as a mouse click or a keypress occurs, Flash Player or
* the AIR application dispatches an event object into the event flow from the
* root of the display list. The event object then makes its way through the
* display list until it reaches the event target, at which point it begins
* its return trip through the display list. This round-trip journey to the
* event target is conceptually divided into three phases: the capture phase
* comprises the journey from the root to the last node before the event
* target's node, the target phase comprises only the event target node, and
* the bubbling phase comprises any subsequent nodes encountered on the return
* trip to the root of the display list.</p>
*
* <p>In general, the easiest way for a user-defined class to gain event
* dispatching capabilities is to extend EventDispatcher. If this is
* impossible (that is, if the class is already extending another class), you
* can instead implement the IEventDispatcher interface, create an
* EventDispatcher member, and write simple hooks to route calls into the
* aggregated EventDispatcher.</p>
*
* @event activate [broadcast event] Dispatched when the Flash Player or AIR
* application gains operating system focus and becomes
* active. This event is a broadcast event, which means that
* it is dispatched by all EventDispatcher objects with a
* listener registered for this event. For more information
* about broadcast events, see the DisplayObject class.
* @event deactivate [broadcast event] Dispatched when the Flash Player or AIR
* application operating loses system focus and is becoming
* inactive. This event is a broadcast event, which means
* that it is dispatched by all EventDispatcher objects with
* a listener registered for this event. For more
* information about broadcast events, see the DisplayObject
* class.]]></haxe_doc>
</class>
<class path="nme.display.IBitmapDrawable" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/IBitmapDrawable.hx" extern="1" interface="1"/>
<class path="nme.display.DisplayObject" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/DisplayObject.hx" extern="1">
<extends path="nme.events.EventDispatcher"/>
<implements path="nme.display.IBitmapDrawable"/>
<localToGlobal public="1" set="method">
<f a="point">
<c path="nme.geom.Point"/>
<c path="nme.geom.Point"/>
</f>
<haxe_doc><![CDATA[* Converts the <code>point</code> object from the display object's (local)
* coordinates to the Stage (global) coordinates.
*
* <p>This method allows you to convert any given <i>x</i> and <i>y</i>
* coordinates from values that are relative to the origin (0,0) of a
* specific display object (local coordinates) to values that are relative to
* the origin of the Stage (global coordinates).</p>
*
* <p>To use this method, first create an instance of the Point class. The
* <i>x</i> and <i>y</i> values that you assign represent local coordinates
* because they relate to the origin of the display object.</p>
*
* <p>You then pass the Point instance that you created as the parameter to
* the <code>localToGlobal()</code> method. The method returns a new Point
* object with <i>x</i> and <i>y</i> values that relate to the origin of the
* Stage instead of the origin of the display object.</p>
*
* @param point The name or identifier of a point created with the Point
* class, specifying the <i>x</i> and <i>y</i> coordinates as
* properties.
* @return A Point object with coordinates relative to the Stage.]]></haxe_doc>
</localToGlobal>
<hitTestPoint public="1" set="method">
<f a="x:y:?shapeFlag">
<c path="Float"/>
<c path="Float"/>
<e path="Bool"/>
<e path="Bool"/>
</f>
<haxe_doc><![CDATA[* Evaluates the display object to see if it overlaps or intersects with the
* point specified by the <code>x</code> and <code>y</code> parameters. The
* <code>x</code> and <code>y</code> parameters specify a point in the
* coordinate space of the Stage, not the display object container that
* contains the display object (unless that display object container is the
* Stage).
*
* @param x The <i>x</i> coordinate to test against this object.
* @param y The <i>y</i> coordinate to test against this object.
* @param shapeFlag Whether to check against the actual pixels of the object
* (<code>true</code>) or the bounding box
* (<code>false</code>).
* @return <code>true</code> if the display object overlaps or intersects
* with the specified point; <code>false</code> otherwise.]]></haxe_doc>
</hitTestPoint>
<hitTestObject public="1" set="method">
<f a="obj">
<c path="nme.display.DisplayObject"/>
<e path="Bool"/>
</f>
<haxe_doc><![CDATA[* Evaluates the bounding box of the display object to see if it overlaps or
* intersects with the bounding box of the <code>obj</code> display object.
*
* @param obj The display object to test against.
* @return <code>true</code> if the bounding boxes of the display objects
* intersect; <code>false</code> if not.]]></haxe_doc>
</hitTestObject>
<globalToLocal public="1" set="method">
<f a="point">
<c path="nme.geom.Point"/>
<c path="nme.geom.Point"/>
</f>
<haxe_doc><![CDATA[* Converts the <code>point</code> object from the Stage (global) coordinates
* to the display object's (local) coordinates.
*
* <p>To use this method, first create an instance of the Point class. The
* <i>x</i> and <i>y</i> values that you assign represent global coordinates
* because they relate to the origin (0,0) of the main display area. Then
* pass the Point instance as the parameter to the
* <code>globalToLocal()</code> method. The method returns a new Point object
* with <i>x</i> and <i>y</i> values that relate to the origin of the display
* object instead of the origin of the Stage.</p>
*
* @param point An object created with the Point class. The Point object
* specifies the <i>x</i> and <i>y</i> coordinates as
* properties.
* @return A Point object with coordinates relative to the display object.]]></haxe_doc>
</globalToLocal>
<getRect public="1" set="method">
<f a="targetCoordinateSpace">
<c path="nme.display.DisplayObject"/>
<c path="nme.geom.Rectangle"/>
</f>
<haxe_doc><![CDATA[* Returns a rectangle that defines the boundary of the display object, based
* on the coordinate system defined by the <code>targetCoordinateSpace</code>
* parameter, excluding any strokes on shapes. The values that the
* <code>getRect()</code> method returns are the same or smaller than those
* returned by the <code>getBounds()</code> method.
*
* <p><b>Note:</b> Use <code>localToGlobal()</code> and
* <code>globalToLocal()</code> methods to convert the display object's local
* coordinates to Stage coordinates, or Stage coordinates to local
* coordinates, respectively.</p>
*
* @param targetCoordinateSpace The display object that defines the
* coordinate system to use.
* @return The rectangle that defines the area of the display object relative
* to the <code>targetCoordinateSpace</code> object's coordinate
* system.]]></haxe_doc>
</getRect>
<getBounds public="1" set="method">
<f a="targetCoordinateSpace">
<c path="nme.display.DisplayObject"/>
<c path="nme.geom.Rectangle"/>
</f>
<haxe_doc><![CDATA[* Returns a rectangle that defines the area of the display object relative
* to the coordinate system of the <code>targetCoordinateSpace</code> object.
* Consider the following code, which shows how the rectangle returned can
* vary depending on the <code>targetCoordinateSpace</code> parameter that
* you pass to the method:
*
* <p><b>Note:</b> Use the <code>localToGlobal()</code> and
* <code>globalToLocal()</code> methods to convert the display object's local
* coordinates to display coordinates, or display coordinates to local
* coordinates, respectively.</p>
*
* <p>The <code>getBounds()</code> method is similar to the
* <code>getRect()</code> method; however, the Rectangle returned by the
* <code>getBounds()</code> method includes any strokes on shapes, whereas
* the Rectangle returned by the <code>getRect()</code> method does not. For
* an example, see the description of the <code>getRect()</code> method.</p>
*
* @param targetCoordinateSpace The display object that defines the
* coordinate system to use.
* @return The rectangle that defines the area of the display object relative
* to the <code>targetCoordinateSpace</code> object's coordinate
* system.]]></haxe_doc>
</getBounds>
<y public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the <i>y</i> coordinate of the DisplayObject instance relative
* to the local coordinates of the parent DisplayObjectContainer. If the
* object is inside a DisplayObjectContainer that has transformations, it is
* in the local coordinate system of the enclosing DisplayObjectContainer.
* Thus, for a DisplayObjectContainer rotated 90° counterclockwise, the
* DisplayObjectContainer's children inherit a coordinate system that is
* rotated 90° counterclockwise. The object's coordinates refer to the
* registration point position.]]></haxe_doc>
</y>
<x public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the <i>x</i> coordinate of the DisplayObject instance relative
* to the local coordinates of the parent DisplayObjectContainer. If the
* object is inside a DisplayObjectContainer that has transformations, it is
* in the local coordinate system of the enclosing DisplayObjectContainer.
* Thus, for a DisplayObjectContainer rotated 90° counterclockwise, the
* DisplayObjectContainer's children inherit a coordinate system that is
* rotated 90° counterclockwise. The object's coordinates refer to the
* registration point position.]]></haxe_doc>
</x>
<width public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the width of the display object, in pixels. The width is
* calculated based on the bounds of the content of the display object. When
* you set the <code>width</code> property, the <code>scaleX</code> property
* is adjusted accordingly, as shown in the following code:
*
* <p>Except for TextField and Video objects, a display object with no
* content (such as an empty sprite) has a width of 0, even if you try to set
* <code>width</code> to a different value.</p>]]></haxe_doc>
</width>
<visible public="1">
<e path="Bool"/>
<haxe_doc><![CDATA[* Whether or not the display object is visible. Display objects that are not
* visible are disabled. For example, if <code>visible=false</code> for an
* InteractiveObject instance, it cannot be clicked.]]></haxe_doc>
</visible>
<transform public="1">
<c path="nme.geom.Transform"/>
<haxe_doc><![CDATA[* An object with properties pertaining to a display object's matrix, color
* transform, and pixel bounds. The specific properties - matrix,
* colorTransform, and three read-only properties
* (<code>concatenatedMatrix</code>, <code>concatenatedColorTransform</code>,
* and <code>pixelBounds</code>) - are described in the entry for the
* Transform class.
*
* <p>Each of the transform object's properties is itself an object. This
* concept is important because the only way to set new values for the matrix
* or colorTransform objects is to create a new object and copy that object
* into the transform.matrix or transform.colorTransform property.</p>
*
* <p>For example, to increase the <code>tx</code> value of a display
* object's matrix, you must make a copy of the entire matrix object, then
* copy the new object into the matrix property of the transform object:</p>
* <pre xml:space="preserve"><code> var myMatrix:Matrix =
* myDisplayObject.transform.matrix; myMatrix.tx += 10;
* myDisplayObject.transform.matrix = myMatrix; </code></pre>
*
* <p>You cannot directly set the <code>tx</code> property. The following
* code has no effect on <code>myDisplayObject</code>: </p>
* <pre xml:space="preserve"><code> myDisplayObject.transform.matrix.tx +=
* 10; </code></pre>
*
* <p>You can also copy an entire transform object and assign it to another
* display object's transform property. For example, the following code
* copies the entire transform object from <code>myOldDisplayObj</code> to
* <code>myNewDisplayObj</code>:</p>
* <code>myNewDisplayObj.transform = myOldDisplayObj.transform;</code>
*
* <p>The resulting display object, <code>myNewDisplayObj</code>, now has the
* same values for its matrix, color transform, and pixel bounds as the old
* display object, <code>myOldDisplayObj</code>.</p>
*
* <p>Note that AIR for TV devices use hardware acceleration, if it is
* available, for color transforms.</p>]]></haxe_doc>
</transform>
<stage public="1" set="null">
<c path="nme.display.Stage"/>
<haxe_doc><![CDATA[* The Stage of the display object. A Flash runtime application has only one
* Stage object. For example, you can create and load multiple display
* objects into the display list, and the <code>stage</code> property of each
* display object refers to the same Stage object (even if the display object
* belongs to a loaded SWF file).
*
* <p>If a display object is not added to the display list, its
* <code>stage</code> property is set to <code>null</code>.</p>]]></haxe_doc>
</stage>
<scrollRect public="1">
<c path="nme.geom.Rectangle"/>
<haxe_doc><![CDATA[* The scroll rectangle bounds of the display object. The display object is
* cropped to the size defined by the rectangle, and it scrolls within the
* rectangle when you change the <code>x</code> and <code>y</code> properties
* of the <code>scrollRect</code> object.
*
* <p>The properties of the <code>scrollRect</code> Rectangle object use the
* display object's coordinate space and are scaled just like the overall
* display object. The corner bounds of the cropped window on the scrolling
* display object are the origin of the display object (0,0) and the point
* defined by the width and height of the rectangle. They are not centered
* around the origin, but use the origin to define the upper-left corner of
* the area. A scrolled display object always scrolls in whole pixel
* increments. </p>
*
* <p>You can scroll an object left and right by setting the <code>x</code>
* property of the <code>scrollRect</code> Rectangle object. You can scroll
* an object up and down by setting the <code>y</code> property of the
* <code>scrollRect</code> Rectangle object. If the display object is rotated
* 90° and you scroll it left and right, the display object actually scrolls
* up and down.</p>]]></haxe_doc>
</scrollRect>
<scaleY public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the vertical scale (percentage) of an object as applied from the
* registration point of the object. The default registration point is (0,0).
* 1.0 is 100% scale.
*
* <p>Scaling the local coordinate system changes the <code>x</code> and
* <code>y</code> property values, which are defined in whole pixels. </p>]]></haxe_doc>
</scaleY>
<scaleX public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the horizontal scale (percentage) of the object as applied from
* the registration point. The default registration point is (0,0). 1.0
* equals 100% scale.
*
* <p>Scaling the local coordinate system changes the <code>x</code> and
* <code>y</code> property values, which are defined in whole pixels. </p>]]></haxe_doc>
</scaleX>
<scale9Grid public="1">
<c path="nme.geom.Rectangle"/>
<haxe_doc><![CDATA[* The current scaling grid that is in effect. If set to <code>null</code>,
* the entire display object is scaled normally when any scale transformation
* is applied.
*
* <p>When you define the <code>scale9Grid</code> property, the display
* object is divided into a grid with nine regions based on the
* <code>scale9Grid</code> rectangle, which defines the center region of the
* grid. The eight other regions of the grid are the following areas: </p>
*
* <ul>
* <li>The upper-left corner outside of the rectangle</li>
* <li>The area above the rectangle </li>
* <li>The upper-right corner outside of the rectangle</li>
* <li>The area to the left of the rectangle</li>
* <li>The area to the right of the rectangle</li>
* <li>The lower-left corner outside of the rectangle</li>
* <li>The area below the rectangle</li>
* <li>The lower-right corner outside of the rectangle</li>
* </ul>
*
* <p>You can think of the eight regions outside of the center (defined by
* the rectangle) as being like a picture frame that has special rules
* applied to it when scaled.</p>
*
* <p>When the <code>scale9Grid</code> property is set and a display object
* is scaled, all text and gradients are scaled normally; however, for other
* types of objects the following rules apply:</p>
*
* <ul>
* <li>Content in the center region is scaled normally. </li>
* <li>Content in the corners is not scaled. </li>
* <li>Content in the top and bottom regions is scaled horizontally only.
* Content in the left and right regions is scaled vertically only.</li>
* <li>All fills (including bitmaps, video, and gradients) are stretched to
* fit their shapes.</li>
* </ul>
*
* <p>If a display object is rotated, all subsequent scaling is normal (and
* the <code>scale9Grid</code> property is ignored).</p>
*
* <p>For example, consider the following display object and a rectangle that
* is applied as the display object's <code>scale9Grid</code>:</p>
*
* <p>A common use for setting <code>scale9Grid</code> is to set up a display
* object to be used as a component, in which edge regions retain the same
* width when the component is scaled.</p>
*
* @throws ArgumentError If you pass an invalid argument to the method.]]></haxe_doc>
</scale9Grid>
<rotation public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the rotation of the DisplayObject instance, in degrees, from its
* original orientation. Values from 0 to 180 represent clockwise rotation;
* values from 0 to -180 represent counterclockwise rotation. Values outside
* this range are added to or subtracted from 360 to obtain a value within
* the range. For example, the statement <code>my_video.rotation = 450</code>
* is the same as <code> my_video.rotation = 90</code>.]]></haxe_doc>
</rotation>
<root public="1" set="null">
<c path="nme.display.DisplayObject"/>
<haxe_doc><![CDATA[* For a display object in a loaded SWF file, the <code>root</code> property
* is the top-most display object in the portion of the display list's tree
* structure represented by that SWF file. For a Bitmap object representing a
* loaded image file, the <code>root</code> property is the Bitmap object
* itself. For the instance of the main class of the first SWF file loaded,
* the <code>root</code> property is the display object itself. The
* <code>root</code> property of the Stage object is the Stage object itself.
* The <code>root</code> property is set to <code>null</code> for any display
* object that has not been added to the display list, unless it has been
* added to a display object container that is off the display list but that
* is a child of the top-most display object in a loaded SWF file.
*
* <p>For example, if you create a new Sprite object by calling the
* <code>Sprite()</code> constructor method, its <code>root</code> property
* is <code>null</code> until you add it to the display list (or to a display
* object container that is off the display list but that is a child of the
* top-most display object in a SWF file).</p>
*
* <p>For a loaded SWF file, even though the Loader object used to load the
* file may not be on the display list, the top-most display object in the
* SWF file has its <code>root</code> property set to itself. The Loader
* object does not have its <code>root</code> property set until it is added
* as a child of a display object for which the <code>root</code> property is
* set.</p>]]></haxe_doc>
</root>
<parent public="1" set="null">
<c path="nme.display.DisplayObjectContainer"/>
<haxe_doc><![CDATA[* Indicates the DisplayObjectContainer object that contains this display
* object. Use the <code>parent</code> property to specify a relative path to
* display objects that are above the current display object in the display
* list hierarchy.
*
* <p>You can use <code>parent</code> to move up multiple levels in the
* display list as in the following:</p>
*
* @throws SecurityError The parent display object belongs to a security
* sandbox to which you do not have access. You can
* avoid this situation by having the parent movie call
* the <code>Security.allowDomain()</code> method.]]></haxe_doc>
</parent>
<opaqueBackground public="1">
<t path="Null"><c path="Int"/></t>
<haxe_doc><![CDATA[* Specifies whether the display object is opaque with a certain background
* color. A transparent bitmap contains alpha channel data and is drawn
* transparently. An opaque bitmap has no alpha channel (and renders faster
* than a transparent bitmap). If the bitmap is opaque, you specify its own
* background color to use.
*
* <p>If set to a number value, the surface is opaque (not transparent) with
* the RGB background color that the number specifies. If set to
* <code>null</code> (the default value), the display object has a
* transparent background.</p>
*
* <p>The <code>opaqueBackground</code> property is intended mainly for use
* with the <code>cacheAsBitmap</code> property, for rendering optimization.
* For display objects in which the <code>cacheAsBitmap</code> property is
* set to true, setting <code>opaqueBackground</code> can improve rendering
* performance.</p>
*
* <p>The opaque background region is <i>not</i> matched when calling the
* <code>hitTestPoint()</code> method with the <code>shapeFlag</code>
* parameter set to <code>true</code>.</p>
*
* <p>The opaque background region does not respond to mouse events.</p>]]></haxe_doc>
</opaqueBackground>
<name public="1">
<c path="String"/>
<haxe_doc><![CDATA[* Indicates the instance name of the DisplayObject. The object can be
* identified in the child list of its parent display object container by
* calling the <code>getChildByName()</code> method of the display object
* container.
*
* @throws IllegalOperationError If you are attempting to set this property
* on an object that was placed on the timeline
* in the Flash authoring tool.]]></haxe_doc>
</name>
<mouseY public="1" set="null">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the y coordinate of the mouse or user input device position, in
* pixels.
*
* <p><b>Note</b>: For a DisplayObject that has been rotated, the returned y
* coordinate will reflect the non-rotated object.</p>]]></haxe_doc>
</mouseY>
<mouseX public="1" set="null">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the x coordinate of the mouse or user input device position, in
* pixels.
*
* <p><b>Note</b>: For a DisplayObject that has been rotated, the returned x
* coordinate will reflect the non-rotated object.</p>]]></haxe_doc>
</mouseX>
<mask public="1">
<c path="nme.display.DisplayObject"/>
<haxe_doc><![CDATA[* The calling display object is masked by the specified <code>mask</code>
* object. To ensure that masking works when the Stage is scaled, the
* <code>mask</code> display object must be in an active part of the display
* list. The <code>mask</code> object itself is not drawn. Set
* <code>mask</code> to <code>null</code> to remove the mask.
*
* <p>To be able to scale a mask object, it must be on the display list. To
* be able to drag a mask Sprite object (by calling its
* <code>startDrag()</code> method), it must be on the display list. To call
* the <code>startDrag()</code> method for a mask sprite based on a
* <code>mouseDown</code> event being dispatched by the sprite, set the
* sprite's <code>buttonMode</code> property to <code>true</code>.</p>
*
* <p>When display objects are cached by setting the
* <code>cacheAsBitmap</code> property to <code>true</code> an the
* <code>cacheAsBitmapMatrix</code> property to a Matrix object, both the
* mask and the display object being masked must be part of the same cached
* bitmap. Thus, if the display object is cached, then the mask must be a
* child of the display object. If an ancestor of the display object on the
* display list is cached, then the mask must be a child of that ancestor or
* one of its descendents. If more than one ancestor of the masked object is
* cached, then the mask must be a descendent of the cached container closest
* to the masked object in the display list.</p>
*
* <p><b>Note:</b> A single <code>mask</code> object cannot be used to mask
* more than one calling display object. When the <code>mask</code> is
* assigned to a second display object, it is removed as the mask of the
* first object, and that object's <code>mask</code> property becomes
* <code>null</code>.</p>]]></haxe_doc>
</mask>
<loaderInfo public="1" set="null">
<c path="nme.display.LoaderInfo"/>
<haxe_doc><![CDATA[* Returns a LoaderInfo object containing information about loading the file
* to which this display object belongs. The <code>loaderInfo</code> property
* is defined only for the root display object of a SWF file or for a loaded
* Bitmap (not for a Bitmap that is drawn with ActionScript). To find the
* <code>loaderInfo</code> object associated with the SWF file that contains
* a display object named <code>myDisplayObject</code>, use
* <code>myDisplayObject.root.loaderInfo</code>.
*
* <p>A large SWF file can monitor its download by calling
* <code>this.root.loaderInfo.addEventListener(Event.COMPLETE,
* func)</code>.</p>]]></haxe_doc>
</loaderInfo>
<height public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the height of the display object, in pixels. The height is
* calculated based on the bounds of the content of the display object. When
* you set the <code>height</code> property, the <code>scaleY</code> property
* is adjusted accordingly, as shown in the following code:
*
* <p>Except for TextField and Video objects, a display object with no
* content (such as an empty sprite) has a height of 0, even if you try to
* set <code>height</code> to a different value.</p>]]></haxe_doc>
</height>
<filters public="1">
<c path="Array"><d/></c>
<haxe_doc><![CDATA[* An indexed array that contains each filter object currently associated
* with the display object. The nme.filters package contains several
* classes that define specific filters you can use.
*
* <p>Filters can be applied in Flash Professional at design time, or at run
* time by using ActionScript code. To apply a filter by using ActionScript,
* you must make a temporary copy of the entire <code>filters</code> array,
* modify the temporary array, then assign the value of the temporary array
* back to the <code>filters</code> array. You cannot directly add a new
* filter object to the <code>filters</code> array.</p>
*
* <p>To add a filter by using ActionScript, perform the following steps
* (assume that the target display object is named
* <code>myDisplayObject</code>):</p>
*
* <ol>
* <li>Create a new filter object by using the constructor method of your
* chosen filter class.</li>
* <li>Assign the value of the <code>myDisplayObject.filters</code> array
* to a temporary array, such as one named <code>myFilters</code>.</li>
* <li>Add the new filter object to the <code>myFilters</code> temporary
* array.</li>
* <li>Assign the value of the temporary array to the
* <code>myDisplayObject.filters</code> array.</li>
* </ol>
*
* <p>If the <code>filters</code> array is undefined, you do not need to use
* a temporary array. Instead, you can directly assign an array literal that
* contains one or more filter objects that you create. The first example in
* the Examples section adds a drop shadow filter by using code that handles
* both defined and undefined <code>filters</code> arrays.</p>
*
* <p>To modify an existing filter object, you must use the technique of
* modifying a copy of the <code>filters</code> array:</p>
*
* <ol>
* <li>Assign the value of the <code>filters</code> array to a temporary
* array, such as one named <code>myFilters</code>.</li>
* <li>Modify the property by using the temporary array,
* <code>myFilters</code>. For example, to set the quality property of the
* first filter in the array, you could use the following code:
* <code>myFilters[0].quality = 1;</code></li>
* <li>Assign the value of the temporary array to the <code>filters</code>
* array.</li>
* </ol>
*
* <p>At load time, if a display object has an associated filter, it is
* marked to cache itself as a transparent bitmap. From this point forward,
* as long as the display object has a valid filter list, the player caches
* the display object as a bitmap. This source bitmap is used as a source
* image for the filter effects. Each display object usually has two bitmaps:
* one with the original unfiltered source display object and another for the
* final image after filtering. The final image is used when rendering. As
* long as the display object does not change, the final image does not need
* updating.</p>
*
* <p>The nme.filters package includes classes for filters. For example, to
* create a DropShadow filter, you would write:</p>
*
* @throws ArgumentError When <code>filters</code> includes a ShaderFilter
* and the shader output type is not compatible with
* this operation (the shader must specify a
* <code>pixel4</code> output).
* @throws ArgumentError When <code>filters</code> includes a ShaderFilter
* and the shader doesn't specify any image input or
* the first input is not an <code>image4</code> input.
* @throws ArgumentError When <code>filters</code> includes a ShaderFilter
* and the shader specifies an image input that isn't
* provided.
* @throws ArgumentError When <code>filters</code> includes a ShaderFilter, a
* ByteArray or Vector.<Number> instance as a shader
* input, and the <code>width</code> and
* <code>height</code> properties aren't specified for
* the ShaderInput object, or the specified values
* don't match the amount of data in the input data.
* See the <code>ShaderInput.input</code> property for
* more information.]]></haxe_doc>
</filters>
<cacheAsBitmap public="1">
<e path="Bool"/>
<haxe_doc><![CDATA[* If set to <code>true</code>, NME will use the software renderer to cache
* an internal bitmap representation of the display object. For native targets,
* this is often much slower than the default hardware renderer. When you
* are using the Flash target, this caching may increase performance for display
* objects that contain complex vector content.
*
* <p>All vector data for a display object that has a cached bitmap is drawn
* to the bitmap instead of the main display. If
* <code>cacheAsBitmapMatrix</code> is null or unsupported, the bitmap is
* then copied to the main display as unstretched, unrotated pixels snapped
* to the nearest pixel boundaries. Pixels are mapped 1 to 1 with the parent
* object. If the bounds of the bitmap change, the bitmap is recreated
* instead of being stretched.</p>
*
* <p>If <code>cacheAsBitmapMatrix</code> is non-null and supported, the
* object is drawn to the off-screen bitmap using that matrix and the
* stretched and/or rotated results of that rendering are used to draw the
* object to the main display.</p>
*
* <p>No internal bitmap is created unless the <code>cacheAsBitmap</code>
* property is set to <code>true</code>.</p>
*
* <p>After you set the <code>cacheAsBitmap</code> property to
* <code>true</code>, the rendering does not change, however the display
* object performs pixel snapping automatically. The animation speed can be
* significantly faster depending on the complexity of the vector content.
* </p>
*
* <p>The <code>cacheAsBitmap</code> property is automatically set to
* <code>true</code> whenever you apply a filter to a display object (when
* its <code>filter</code> array is not empty), and if a display object has a
* filter applied to it, <code>cacheAsBitmap</code> is reported as
* <code>true</code> for that display object, even if you set the property to
* <code>false</code>. If you clear all filters for a display object, the
* <code>cacheAsBitmap</code> setting changes to what it was last set to.</p>
*
* <p>A display object does not use a bitmap even if the
* <code>cacheAsBitmap</code> property is set to <code>true</code> and
* instead renders from vector data in the following cases:</p>
*
* <ul>
* <li>The bitmap is too large. In AIR 1.5 and Flash Player 10, the maximum
* size for a bitmap image is 8,191 pixels in width or height, and the total
* number of pixels cannot exceed 16,777,215 pixels. (So, if a bitmap image
* is 8,191 pixels wide, it can only be 2,048 pixels high.) In Flash Player 9
* and earlier, the limitation is is 2880 pixels in height and 2,880 pixels
* in width.</li>
* <li>The bitmap fails to allocate (out of memory error). </li>
* </ul>
*
* <p>The <code>cacheAsBitmap</code> property is best used with movie clips
* that have mostly static content and that do not scale and rotate
* frequently. With such movie clips, <code>cacheAsBitmap</code> can lead to
* performance increases when the movie clip is translated (when its <i>x</i>
* and <i>y</i> position is changed).</p>]]></haxe_doc>
</cacheAsBitmap>
<blendMode public="1">
<e path="nme.display.BlendMode"/>
<haxe_doc><![CDATA[* A value from the BlendMode class that specifies which blend mode to use. A
* bitmap can be drawn internally in two ways. If you have a blend mode
* enabled or an external clipping mask, the bitmap is drawn by adding a
* bitmap-filled square shape to the vector render. If you attempt to set
* this property to an invalid value, Flash runtimes set the value to
* <code>BlendMode.NORMAL</code>.
*
* <p>The <code>blendMode</code> property affects each pixel of the display
* object. Each pixel is composed of three constituent colors (red, green,
* and blue), and each constituent color has a value between 0x00 and 0xFF.
* Flash Player or Adobe AIR compares each constituent color of one pixel in
* the movie clip with the corresponding color of the pixel in the
* background. For example, if <code>blendMode</code> is set to
* <code>BlendMode.LIGHTEN</code>, Flash Player or Adobe AIR compares the red
* value of the display object with the red value of the background, and uses
* the lighter of the two as the value for the red component of the displayed
* color.</p>
*
* <p>The following table describes the <code>blendMode</code> settings. The
* BlendMode class defines string values you can use. The illustrations in
* the table show <code>blendMode</code> values applied to a circular display
* object (2) superimposed on another display object (1).</p>]]></haxe_doc>
</blendMode>
<alpha public="1">
<c path="Float"/>
<haxe_doc><![CDATA[* Indicates the alpha transparency value of the object specified. Valid
* values are 0 (fully transparent) to 1 (fully opaque). The default value is
* 1. Display objects with <code>alpha</code> set to 0 <i>are</i> active,
* even though they are invisible.]]></haxe_doc>
</alpha>
<haxe_doc><![CDATA[* The DisplayObject class is the base class for all objects that can be
* placed on the display list. The display list manages all objects displayed
* in NME. Use the DisplayObjectContainer class to arrange the
* display objects in the display list. DisplayObjectContainer objects can
* have child display objects, while other display objects, such as Shape and
* TextField objects, are "leaf" nodes that have only parents and siblings, no
* children.
*
* <p>The DisplayObject class supports basic functionality like the <i>x</i>
* and <i>y</i> position of an object, as well as more advanced properties of
* the object such as its transformation matrix. </p>
*
* <p>DisplayObject is an abstract base class; therefore, you cannot call
* DisplayObject directly. Invoking <code>new DisplayObject()</code> throws an
* <code>ArgumentError</code> exception. </p>
*
* <p>All display objects inherit from the DisplayObject class.</p>
*
* <p>The DisplayObject class itself does not include any APIs for rendering
* content onscreen. For that reason, if you want create a custom subclass of
* the DisplayObject class, you will want to extend one of its subclasses that
* do have APIs for rendering content onscreen, such as the Shape, Sprite,
* Bitmap, SimpleButton, TextField, or MovieClip class.</p>
*
* <p>The DisplayObject class contains several broadcast events. Normally, the
* target of any particular event is a specific DisplayObject instance. For
* example, the target of an <code>added</code> event is the specific
* DisplayObject instance that was added to the display list. Having a single
* target restricts the placement of event listeners to that target and in
* some cases the target's ancestors on the display list. With broadcast
* events, however, the target is not a specific DisplayObject instance, but
* rather all DisplayObject instances, including those that are not on the
* display list. This means that you can add a listener to any DisplayObject
* instance to listen for broadcast events. In addition to the broadcast
* events listed in the DisplayObject class's Events table, the DisplayObject
* class also inherits two broadcast events from the EventDispatcher class:
* <code>activate</code> and <code>deactivate</code>.</p>
*
* <p>Some properties previously used in the ActionScript 1.0 and 2.0
* MovieClip, TextField, and Button classes (such as <code>_alpha</code>,
* <code>_height</code>, <code>_name</code>, <code>_width</code>,
* <code>_x</code>, <code>_y</code>, and others) have equivalents in the
* ActionScript 3.0 DisplayObject class that are renamed so that they no
* longer begin with the underscore (_) character.</p>
*
* <p>For more information, see the "Display Programming" chapter of the
* <i>ActionScript 3.0 Developer's Guide</i>.</p>
*
* @event added Dispatched when a display object is added to the
* display list. The following methods trigger this
* event:
* <code>DisplayObjectContainer.addChild()</code>,
* <code>DisplayObjectContainer.addChildAt()</code>.
* @event addedToStage Dispatched when a display object is added to the on
* stage display list, either directly or through the
* addition of a sub tree in which the display object
* is contained. The following methods trigger this
* event:
* <code>DisplayObjectContainer.addChild()</code>,
* <code>DisplayObjectContainer.addChildAt()</code>.
* @event enterFrame [broadcast event] Dispatched when the playhead is
* entering a new frame. If the playhead is not
* moving, or if there is only one frame, this event
* is dispatched continuously in conjunction with the
* frame rate. This event is a broadcast event, which
* means that it is dispatched by all display objects
* with a listener registered for this event.
* @event exitFrame [broadcast event] Dispatched when the playhead is
* exiting the current frame. All frame scripts have
* been run. If the playhead is not moving, or if
* there is only one frame, this event is dispatched
* continuously in conjunction with the frame rate.
* This event is a broadcast event, which means that
* it is dispatched by all display objects with a
* listener registered for this event.
* @event frameConstructed [broadcast event] Dispatched after the constructors
* of frame display objects have run but before frame
* scripts have run. If the playhead is not moving, or
* if there is only one frame, this event is
* dispatched continuously in conjunction with the
* frame rate. This event is a broadcast event, which
* means that it is dispatched by all display objects
* with a listener registered for this event.
* @event removed Dispatched when a display object is about to be
* removed from the display list. Two methods of the
* DisplayObjectContainer class generate this event:
* <code>removeChild()</code> and
* <code>removeChildAt()</code>.
*
* <p>The following methods of a
* DisplayObjectContainer object also generate this
* event if an object must be removed to make room for
* the new object: <code>addChild()</code>,
* <code>addChildAt()</code>, and
* <code>setChildIndex()</code>. </p>
* @event removedFromStage Dispatched when a display object is about to be
* removed from the display list, either directly or
* through the removal of a sub tree in which the
* display object is contained. Two methods of the
* DisplayObjectContainer class generate this event:
* <code>removeChild()</code> and
* <code>removeChildAt()</code>.
*
* <p>The following methods of a
* DisplayObjectContainer object also generate this
* event if an object must be removed to make room for
* the new object: <code>addChild()</code>,
* <code>addChildAt()</code>, and
* <code>setChildIndex()</code>. </p>
* @event render [broadcast event] Dispatched when the display list
* is about to be updated and rendered. This event
* provides the last opportunity for objects listening
* for this event to make changes before the display
* list is rendered. You must call the
* <code>invalidate()</code> method of the Stage
* object each time you want a <code>render</code>
* event to be dispatched. <code>Render</code> events
* are dispatched to an object only if there is mutual
* trust between it and the object that called
* <code>Stage.invalidate()</code>. This event is a
* broadcast event, which means that it is dispatched
* by all display objects with a listener registered
* for this event.
*
* <p><b>Note: </b>This event is not dispatched if the
* display is not rendering. This is the case when the
* content is either minimized or obscured. </p>]]></haxe_doc>
</class>
<class path="nme.display.Bitmap" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/Bitmap.hx" extern="1">
<extends path="nme.display.DisplayObject"/>
<smoothing public="1">
<e path="Bool"/>
<haxe_doc><![CDATA[* Controls whether or not the bitmap is smoothed when scaled. If
* <code>true</code>, the bitmap is smoothed when scaled. If
* <code>false</code>, the bitmap is not smoothed when scaled.]]></haxe_doc>
</smoothing>
<pixelSnapping public="1">
<e path="nme.display.PixelSnapping"/>
<haxe_doc><![CDATA[* Controls whether or not the Bitmap object is snapped to the nearest pixel.
* This value is ignored in the native and HTML5 targets.
* The PixelSnapping class includes possible values:
* <ul>
* <li><code>PixelSnapping.NEVER</code> - No pixel snapping occurs.</li>
* <li><code>PixelSnapping.ALWAYS</code> - The image is always snapped to
* the nearest pixel, independent of transformation.</li>
* <li><code>PixelSnapping.AUTO</code> - The image is snapped to the
* nearest pixel if it is drawn with no rotation or skew and it is drawn at a
* scale factor of 99.9% to 100.1%. If these conditions are satisfied, the
* bitmap image is drawn at 100% scale, snapped to the nearest pixel.
* When targeting Flash Player, this value allows the image to be drawn as fast
* as possible using the internal vector renderer.</li>
* </ul>]]></haxe_doc>
</pixelSnapping>
<bitmapData public="1">
<c path="nme.display.BitmapData"/>
<haxe_doc>* The BitmapData object being referenced.</haxe_doc>
</bitmapData>
<new public="1" set="method"><f a="?bitmapData:?pixelSnapping:?smoothing">
<c path="nme.display.BitmapData"/>
<e path="nme.display.PixelSnapping"/>
<e path="Bool"/>
<e path="Void"/>
</f></new>
<haxe_doc><![CDATA[* The Bitmap class represents display objects that represent bitmap images.
* These can be images that you load with the <code>nme.Assets</code> or
* <code>nme.display.Loader</code> classes, or they can be images that you
* create with the <code>Bitmap()</code> constructor.
*
* <p>The <code>Bitmap()</code> constructor allows you to create a Bitmap
* object that contains a reference to a BitmapData object. After you create a
* Bitmap object, use the <code>addChild()</code> or <code>addChildAt()</code>
* method of the parent DisplayObjectContainer instance to place the bitmap on
* the display list.</p>
*
* <p>A Bitmap object can share its BitmapData reference among several Bitmap
* objects, independent of translation or rotation properties. Because you can
* create multiple Bitmap objects that reference the same BitmapData object,
* multiple display objects can use the same complex BitmapData object without
* incurring the memory overhead of a BitmapData object for each display
* object instance.</p>
*
* <p>A BitmapData object can be drawn to the screen by a Bitmap object in one
* of two ways: by using the default hardware renderer with a single hardware surface,
* or by using the slower software renderer when 3D acceleration is not available.</p>
*
* <p>If you would prefer to perform a batch rendering command, rather than using a
* single surface for each Bitmap object, you can also draw to the screen using the
* <code>drawTiles()</code> or <code>drawTriangles()</code> methods which are
* available to <code>nme.display.Tilesheet</code> and <code>nme.display.Graphics
* objects.</code></p>
*
* <p><b>Note:</b> The Bitmap class is not a subclass of the InteractiveObject
* class, so it cannot dispatch mouse events. However, you can use the
* <code>addEventListener()</code> method of the display object container that
* contains the Bitmap object.</p>]]></haxe_doc>
</class>
<class path="nme.display.BitmapData" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/BitmapData.hx" extern="1">
<implements path="nme.display.IBitmapDrawable"/>
<unlock public="1" set="method">
<f a="?changeRect">
<c path="nme.geom.Rectangle"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Unlocks an image so that any objects that reference the BitmapData object,
* such as Bitmap objects, are updated when this BitmapData object changes.
* To improve performance, use this method along with the <code>lock()</code>
* method before and after numerous calls to the <code>setPixel()</code> or
* <code>setPixel32()</code> method.
*
* @param changeRect The area of the BitmapData object that has changed. If
* you do not specify a value for this parameter, the
* entire area of the BitmapData object is considered
* changed.]]></haxe_doc>
</unlock>
<setVector public="1" set="method">
<f a="rect:inputVector">
<c path="nme.geom.Rectangle"/>
<t path="nme.Vector"><c path="Int"/></t>
<e path="Void"/>
</f>
<haxe_doc>* Converts a Vector into a rectangular region of pixel data. For each pixel,
* a Vector element is read and written into the BitmapData pixel. The data
* in the Vector is expected to be 32-bit ARGB pixel values.
*
* @param rect Specifies the rectangular region of the BitmapData object.
* @throws RangeError The vector array is not large enough to read all the
* pixel data.</haxe_doc>
</setVector>
<setPixels public="1" set="method">
<f a="rect:inputByteArray">
<c path="nme.geom.Rectangle"/>
<c path="nme.utils.ByteArray"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Converts a byte array into a rectangular region of pixel data. For each
* pixel, the <code>ByteArray.readUnsignedInt()</code> method is called and
* the return value is written into the pixel. If the byte array ends before
* the full rectangle is written, the function returns. The data in the byte
* array is expected to be 32-bit ARGB pixel values. No seeking is performed
* on the byte array before or after the pixels are read.
*
* @param rect Specifies the rectangular region of the BitmapData
* object.
* @param inputByteArray A ByteArray object that consists of 32-bit
* unmultiplied pixel values to be used in the
* rectangular region.
* @throws EOFError The <code>inputByteArray</code> object does not include
* enough data to fill the area of the <code>rect</code>
* rectangle. The method fills as many pixels as possible
* before throwing the exception.
* @throws TypeError The rect or inputByteArray are null.]]></haxe_doc>
</setPixels>
<setPixel32 public="1" set="method">
<f a="x:y:color">
<c path="Int"/>
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Sets the color and alpha transparency values of a single pixel of a
* BitmapData object. This method is similar to the <code>setPixel()</code>
* method; the main difference is that the <code>setPixel32()</code> method
* takes an ARGB color value that contains alpha channel information.
*
* <p>All pixels in a BitmapData object are stored as premultiplied color
* values. A premultiplied image pixel has the red, green, and blue color
* channel values already multiplied by the alpha data. For example, if the
* alpha value is 0, the values for the RGB channels are also 0, independent
* of their unmultiplied values. This loss of data can cause some problems
* when you perform operations. All BitmapData methods take and return
* unmultiplied values. The internal pixel representation is converted from
* premultiplied to unmultiplied before it is returned as a value. During a
* set operation, the pixel value is premultiplied before the raw image pixel
* is set.</p>
*
* <p><b>Note:</b> To increase performance, when you use the
* <code>setPixel()</code> or <code>setPixel32()</code> method repeatedly,
* call the <code>lock()</code> method before you call the
* <code>setPixel()</code> or <code>setPixel32()</code> method, and then call
* the <code>unlock()</code> method when you have made all pixel changes.
* This process prevents objects that reference this BitmapData instance from
* updating until you finish making the pixel changes.</p>
*
* @param x The <i>x</i> position of the pixel whose value changes.
* @param y The <i>y</i> position of the pixel whose value changes.
* @param color The resulting ARGB color for the pixel. If the bitmap is
* opaque (not transparent), the alpha transparency portion of
* this color value is ignored.]]></haxe_doc>
</setPixel32>
<setPixel public="1" set="method">
<f a="x:y:color">
<c path="Int"/>
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Sets a single pixel of a BitmapData object. The current alpha channel
* value of the image pixel is preserved during this operation. The value of
* the RGB color parameter is treated as an unmultiplied color value.
*
* <p><b>Note:</b> To increase performance, when you use the
* <code>setPixel()</code> or <code>setPixel32()</code> method repeatedly,
* call the <code>lock()</code> method before you call the
* <code>setPixel()</code> or <code>setPixel32()</code> method, and then call
* the <code>unlock()</code> method when you have made all pixel changes.
* This process prevents objects that reference this BitmapData instance from
* updating until you finish making the pixel changes.</p>
*
* @param x The <i>x</i> position of the pixel whose value changes.
* @param y The <i>y</i> position of the pixel whose value changes.
* @param color The resulting RGB color for the pixel.]]></haxe_doc>
</setPixel>
<scroll public="1" set="method">
<f a="x:y">
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Scrolls an image by a certain (<i>x</i>, <i>y</i>) pixel amount. Edge
* regions outside the scrolling area are left unchanged.
*
* @param x The amount by which to scroll horizontally.
* @param y The amount by which to scroll vertically.]]></haxe_doc>
</scroll>
<noise public="1" set="method">
<f a="randomSeed:?low:?high:?channelOptions:?grayScale">
<c path="Int"/>
<c path="Int"/>
<c path="Int"/>
<c path="Int"/>
<e path="Bool"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Fills an image with pixels representing random noise.
*
* @param randomSeed The random seed number to use. If you keep all other
* parameters the same, you can generate different
* pseudo-random results by varying the random seed
* value. The noise function is a mapping function, not
* a true random-number generation function, so it
* creates the same results each time from the same
* random seed.
* @param low The lowest value to generate for each channel (0 to
* 255).
* @param high The highest value to generate for each channel (0 to
* 255).
* @param channelOptions A number that can be a combination of any of the
* four color channel values
* (<code>BitmapDataChannel.RED</code>,
* <code>BitmapDataChannel.BLUE</code>,
* <code>BitmapDataChannel.GREEN</code>, and
* <code>BitmapDataChannel.ALPHA</code>). You can use
* the logical OR operator (<code>|</code>) to combine
* channel values.
* @param grayScale A Boolean value. If the value is <code>true</code>,
* a grayscale image is created by setting all of the
* color channels to the same value. The alpha channel
* selection is not affected by setting this parameter
* to <code>true</code>.]]></haxe_doc>
</noise>
<lock public="1" set="method">
<f a=""><e path="Void"/></f>
<haxe_doc><![CDATA[* Locks an image so that any objects that reference the BitmapData object,
* such as Bitmap objects, are not updated when this BitmapData object
* changes. To improve performance, use this method along with the
* <code>unlock()</code> method before and after numerous calls to the
* <code>setPixel()</code> or <code>setPixel32()</code> method.
*]]></haxe_doc>
</lock>
<getVector public="1" set="method">
<f a="rect">
<c path="nme.geom.Rectangle"/>
<t path="nme.Vector"><c path="Int"/></t>
</f>
<haxe_doc>* Generates a vector array from a rectangular region of pixel data. Returns
* a Vector object of unsigned integers (a 32-bit unmultiplied pixel value)
* for the specified rectangle.
*
* @param rect A rectangular area in the current BitmapData object.
* @return A Vector representing the given Rectangle.
* @throws TypeError The rect is null.</haxe_doc>
</getVector>
<getPixels public="1" set="method">
<f a="rect">
<c path="nme.geom.Rectangle"/>
<c path="nme.utils.ByteArray"/>
</f>
<haxe_doc>* Generates a byte array from a rectangular region of pixel data. Writes an
* unsigned integer (a 32-bit unmultiplied pixel value) for each pixel into
* the byte array.
*
* @param rect A rectangular area in the current BitmapData object.
* @return A ByteArray representing the pixels in the given Rectangle.
* @throws TypeError The rect is null.</haxe_doc>
</getPixels>
<getPixel32 public="1" set="method">
<f a="x:y">
<c path="Int"/>
<c path="Int"/>
<c path="Int"/>
</f>
<haxe_doc><![CDATA[* Returns an ARGB color value that contains alpha channel data and RGB data.
* This method is similar to the <code>getPixel()</code> method, which
* returns an RGB color without alpha channel data.
*
* <p>All pixels in a BitmapData object are stored as premultiplied color
* values. A premultiplied image pixel has the red, green, and blue color
* channel values already multiplied by the alpha data. For example, if the
* alpha value is 0, the values for the RGB channels are also 0, independent
* of their unmultiplied values. This loss of data can cause some problems
* when you perform operations. All BitmapData methods take and return
* unmultiplied values. The internal pixel representation is converted from
* premultiplied to unmultiplied before it is returned as a value. During a
* set operation, the pixel value is premultiplied before the raw image pixel
* is set.</p>
*
* @param x The <i>x</i> position of the pixel.
* @param y The <i>y</i> position of the pixel.
* @return A number representing an ARGB pixel value. If the (<i>x</i>,
* <i>y</i>) coordinates are outside the bounds of the image, 0 is
* returned.]]></haxe_doc>
</getPixel32>
<getPixel public="1" set="method">
<f a="x:y">
<c path="Int"/>
<c path="Int"/>
<c path="Int"/>
</f>
<haxe_doc><![CDATA[* Returns an integer that represents an RGB pixel value from a BitmapData
* object at a specific point (<i>x</i>, <i>y</i>). The
* <code>getPixel()</code> method returns an unmultiplied pixel value. No
* alpha information is returned.
*
* <p>All pixels in a BitmapData object are stored as premultiplied color
* values. A premultiplied image pixel has the red, green, and blue color
* channel values already multiplied by the alpha data. For example, if the
* alpha value is 0, the values for the RGB channels are also 0, independent
* of their unmultiplied values. This loss of data can cause some problems
* when you perform operations. All BitmapData methods take and return
* unmultiplied values. The internal pixel representation is converted from
* premultiplied to unmultiplied before it is returned as a value. During a
* set operation, the pixel value is premultiplied before the raw image pixel
* is set.</p>
*
* @param x The <i>x</i> position of the pixel.
* @param y The <i>y</i> position of the pixel.
* @return A number that represents an RGB pixel value. If the (<i>x</i>,
* <i>y</i>) coordinates are outside the bounds of the image, the
* method returns 0.]]></haxe_doc>
</getPixel>
<getColorBoundsRect public="1" set="method">
<f a="mask:color:?findColor">
<c path="Int"/>
<c path="Int"/>
<e path="Bool"/>
<c path="nme.geom.Rectangle"/>
</f>
<haxe_doc><![CDATA[* Determines a rectangular region that either fully encloses all pixels of a
* specified color within the bitmap image (if the <code>findColor</code>
* parameter is set to <code>true</code>) or fully encloses all pixels that
* do not include the specified color (if the <code>findColor</code>
* parameter is set to <code>false</code>).
*
* <p>For example, if you have a source image and you want to determine the
* rectangle of the image that contains a nonzero alpha channel, pass
* <code>{mask: 0xFF000000, color: 0x00000000}</code> as parameters. If the
* <code>findColor</code> parameter is set to <code>true</code>, the entire
* image is searched for the bounds of pixels for which <code>(value & mask)
* == color</code> (where <code>value</code> is the color value of the
* pixel). If the <code>findColor</code> parameter is set to
* <code>false</code>, the entire image is searched for the bounds of pixels
* for which <code>(value & mask) != color</code> (where <code>value</code>
* is the color value of the pixel). To determine white space around an
* image, pass <code>{mask: 0xFFFFFFFF, color: 0xFFFFFFFF}</code> to find the
* bounds of nonwhite pixels.</p>
*
* @param mask A hexadecimal value, specifying the bits of the ARGB
* color to consider. The color value is combined with this
* hexadecimal value, by using the <code>&</code> (bitwise
* AND) operator.
* @param color A hexadecimal value, specifying the ARGB color to match
* (if <code>findColor</code> is set to <code>true</code>)
* or <i>not</i> to match (if <code>findColor</code> is set
* to <code>false</code>).
* @param findColor If the value is set to <code>true</code>, returns the
* bounds of a color value in an image. If the value is set
* to <code>false</code>, returns the bounds of where this
* color doesn't exist in an image.
* @return The region of the image that is the specified color.]]></haxe_doc>
</getColorBoundsRect>
<generateFilterRect public="1" set="method">
<f a="sourceRect:filter">
<c path="nme.geom.Rectangle"/>
<c path="nme.filters.BitmapFilter"/>
<c path="nme.geom.Rectangle"/>
</f>
<haxe_doc><![CDATA[* Determines the destination rectangle that the <code>applyFilter()</code>
* method call affects, given a BitmapData object, a source rectangle, and a
* filter object.
*
* <p>For example, a blur filter normally affects an area larger than the
* size of the original image. A 100 x 200 pixel image that is being filtered
* by a default BlurFilter instance, where <code>blurX = blurY = 4</code>
* generates a destination rectangle of <code>(-2,-2,104,204)</code>. The
* <code>generateFilterRect()</code> method lets you find out the size of
* this destination rectangle in advance so that you can size the destination
* image appropriately before you perform a filter operation.</p>
*
* <p>Some filters clip their destination rectangle based on the source image
* size. For example, an inner <code>DropShadow</code> does not generate a
* larger result than its source image. In this API, the BitmapData object is
* used as the source bounds and not the source <code>rect</code>
* parameter.</p>
*
* @param sourceRect A rectangle defining the area of the source image to use
* as input.
* @param filter A filter object that you use to calculate the
* destination rectangle.
* @return A destination rectangle computed by using an image, the
* <code>sourceRect</code> parameter, and a filter.
* @throws TypeError The sourceRect or filter are null.]]></haxe_doc>
</generateFilterRect>
<fillRect public="1" set="method">
<f a="rect:color">
<c path="nme.geom.Rectangle"/>
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc>* Fills a rectangular area of pixels with a specified ARGB color.
*
* @param rect The rectangular area to fill.
* @param color The ARGB color value that fills the area. ARGB colors are
* often specified in hexadecimal format; for example,
* 0xFF336699.
* @throws TypeError The rect is null.</haxe_doc>
</fillRect>
<encode public="1" set="method">
<f a="format:?quality">
<c path="String"/>
<c path="Float"/>
<c path="nme.utils.ByteArray"/>
</f>
<haxe_doc>* Encodes the current image as a JPG or PNG format ByteArray.
*
* This method is not available to the HTML5 and Flash targets.
*
* @param format The encoding format, either "png" or "jpg".
* @param quality The encoding quality, when encoding with the JPG format.
* @return A ByteArray in the specified encoding format</haxe_doc>
</encode>
<draw public="1" set="method">
<f a="source:?matrix:?colorTransform:?blendMode:?clipRect:?smoothing">
<c path="nme.display.IBitmapDrawable"/>
<c path="nme.geom.Matrix"/>
<c path="nme.geom.ColorTransform"/>
<e path="nme.display.BlendMode"/>
<c path="nme.geom.Rectangle"/>
<e path="Bool"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Draws the <code>source</code> display object onto the bitmap image, using
* the NME software renderer. You can specify <code>matrix</code>,
* <code>colorTransform</code>, <code>blendMode</code>, and a destination
* <code>clipRect</code> parameter to control how the rendering performs.
* Optionally, you can specify whether the bitmap should be smoothed when
* scaled (this works only if the source object is a BitmapData object).
*
* <p>The source display object does not use any of its applied
* transformations for this call. It is treated as it exists in the library
* or file, with no matrix transform, no color transform, and no blend mode.
* To draw a display object (such as a movie clip) by using its own transform
* properties, you can copy its <code>transform</code> property object to the
* <code>transform</code> property of the Bitmap object that uses the
* BitmapData object.</p>
*
* @param source The display object or BitmapData object to draw to
* the BitmapData object. (The DisplayObject and
* BitmapData classes implement the IBitmapDrawable
* interface.)
* @param matrix A Matrix object used to scale, rotate, or translate
* the coordinates of the bitmap. If you do not want to
* apply a matrix transformation to the image, set this
* parameter to an identity matrix, created with the
* default <code>new Matrix()</code> constructor, or
* pass a <code>null</code> value.
* @param colorTransform A ColorTransform object that you use to adjust the
* color values of the bitmap. If no object is
* supplied, the bitmap image's colors are not
* transformed. If you must pass this parameter but you
* do not want to transform the image, set this
* parameter to a ColorTransform object created with
* the default <code>new ColorTransform()</code>
* constructor.
* @param blendMode A string value, from the nme.display.BlendMode
* class, specifying the blend mode to be applied to
* the resulting bitmap.
* @param clipRect A Rectangle object that defines the area of the
* source object to draw. If you do not supply this
* value, no clipping occurs and the entire source
* object is drawn.
* @param smoothing A Boolean value that determines whether a BitmapData
* object is smoothed when scaled or rotated, due to a
* scaling or rotation in the <code>matrix</code>
* parameter. The <code>smoothing</code> parameter only
* applies if the <code>source</code> parameter is a
* BitmapData object. With <code>smoothing</code> set
* to <code>false</code>, the rotated or scaled
* BitmapData image can appear pixelated or jagged. For
* example, the following two images use the same
* BitmapData object for the <code>source</code>
* parameter, but the <code>smoothing</code> parameter
* is set to <code>true</code> on the left and
* <code>false</code> on the right:
*
* <p>Drawing a bitmap with <code>smoothing</code> set
* to <code>true</code> takes longer than doing so with
* <code>smoothing</code> set to
* <code>false</code>.</p>
* @throws ArgumentError The <code>source</code> parameter is not a
* BitmapData or DisplayObject object.
* @throws ArgumentError The source is null or not a valid IBitmapDrawable
* object.
* @throws SecurityError The <code>source</code> object and (in the case of a
* Sprite or MovieClip object) all of its child objects
* do not come from the same domain as the caller, or
* are not in a content that is accessible to the
* caller by having called the
* <code>Security.allowDomain()</code> method. This
* restriction does not apply to AIR content in the
* application security sandbox.]]></haxe_doc>
</draw>
<dispose public="1" set="method">
<f a=""><e path="Void"/></f>
<haxe_doc><![CDATA[* Frees memory that is used to store the BitmapData object.
*
* <p>When the <code>dispose()</code> method is called on an image, the width
* and height of the image are set to 0. All subsequent calls to methods or
* properties of this BitmapData instance fail, and an exception is thrown.
* </p>
*
* <p><code>BitmapData.dispose()</code> releases the memory occupied by the
* actual bitmap data, immediately (a bitmap can consume up to 64 MB of
* memory). After using <code>BitmapData.dispose()</code>, the BitmapData
* object is no longer usable and an exception may be thrown if
* you call functions on the BitmapData object. However,
* <code>BitmapData.dispose()</code> does not garbage collect the BitmapData
* object (approximately 128 bytes); the memory occupied by the actual
* BitmapData object is released at the time the BitmapData object is
* collected by the garbage collector.</p>
*]]></haxe_doc>
</dispose>
<copyPixels public="1" set="method">
<f a="sourceBitmapData:sourceRect:destPoint:?alphaBitmapData:?alphaPoint:?mergeAlpha">
<c path="nme.display.BitmapData"/>
<c path="nme.geom.Rectangle"/>
<c path="nme.geom.Point"/>
<c path="nme.display.BitmapData"/>
<c path="nme.geom.Point"/>
<e path="Bool"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Provides a fast routine to perform pixel manipulation between images with
* no stretching, rotation, or color effects. This method copies a
* rectangular area of a source image to a rectangular area of the same size
* at the destination point of the destination BitmapData object.
*
* <p>If you include the <code>alphaBitmap</code> and <code>alphaPoint</code>
* parameters, you can use a secondary image as an alpha source for the
* source image. If the source image has alpha data, both sets of alpha data
* are used to composite pixels from the source image to the destination
* image. The <code>alphaPoint</code> parameter is the point in the alpha
* image that corresponds to the upper-left corner of the source rectangle.
* Any pixels outside the intersection of the source image and alpha image
* are not copied to the destination image.</p>
*
* <p>The <code>mergeAlpha</code> property controls whether or not the alpha
* channel is used when a transparent image is copied onto another
* transparent image. To copy pixels with the alpha channel data, set the
* <code>mergeAlpha</code> property to <code>true</code>. By default, the
* <code>mergeAlpha</code> property is <code>false</code>.</p>
*
* @param sourceBitmapData The input bitmap image from which to copy pixels.
* The source image can be a different BitmapData
* instance, or it can refer to the current
* BitmapData instance.
* @param sourceRect A rectangle that defines the area of the source
* image to use as input.
* @param destPoint The destination point that represents the
* upper-left corner of the rectangular area where
* the new pixels are placed.
* @param alphaBitmapData A secondary, alpha BitmapData object source.
* @param alphaPoint The point in the alpha BitmapData object source
* that corresponds to the upper-left corner of the
* <code>sourceRect</code> parameter.
* @param mergeAlpha To use the alpha channel, set the value to
* <code>true</code>. To copy pixels with no alpha
* channel, set the value to <code>false</code>.
* @throws TypeError The sourceBitmapData, sourceRect, destPoint are null.]]></haxe_doc>
</copyPixels>
<copyChannel public="1" set="method">
<f a="sourceBitmapData:sourceRect:destPoint:sourceChannel:destChannel">
<c path="nme.display.BitmapData"/>
<c path="nme.geom.Rectangle"/>
<c path="nme.geom.Point"/>
<c path="Int"/>
<c path="Int"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Transfers data from one channel of another BitmapData object or the
* current BitmapData object into a channel of the current BitmapData object.
* All of the data in the other channels in the destination BitmapData object
* are preserved.
*
* <p>The source channel value and destination channel value can be one of
* following values: </p>
*
* <ul>
* <li><code>BitmapDataChannel.RED</code></li>
* <li><code>BitmapDataChannel.GREEN</code></li>
* <li><code>BitmapDataChannel.BLUE</code></li>
* <li><code>BitmapDataChannel.ALPHA</code></li>
* </ul>
*
* @param sourceBitmapData The input bitmap image to use. The source image
* can be a different BitmapData object or it can
* refer to the current BitmapData object.
* @param sourceRect The source Rectangle object. To copy only channel
* data from a smaller area within the bitmap,
* specify a source rectangle that is smaller than
* the overall size of the BitmapData object.
* @param destPoint The destination Point object that represents the
* upper-left corner of the rectangular area where
* the new channel data is placed. To copy only
* channel data from one area to a different area in
* the destination image, specify a point other than
* (0,0).
* @param sourceChannel The source channel. Use a value from the
* BitmapDataChannel class
* (<code>BitmapDataChannel.RED</code>,
* <code>BitmapDataChannel.BLUE</code>,
* <code>BitmapDataChannel.GREEN</code>,
* <code>BitmapDataChannel.ALPHA</code>).
* @param destChannel The destination channel. Use a value from the
* BitmapDataChannel class
* (<code>BitmapDataChannel.RED</code>,
* <code>BitmapDataChannel.BLUE</code>,
* <code>BitmapDataChannel.GREEN</code>,
* <code>BitmapDataChannel.ALPHA</code>).
* @throws TypeError The sourceBitmapData, sourceRect or destPoint are null.]]></haxe_doc>
</copyChannel>
<colorTransform public="1" set="method">
<f a="rect:colorTransform">
<c path="nme.geom.Rectangle"/>
<c path="nme.geom.ColorTransform"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Adjusts the color values in a specified area of a bitmap image by using a <code>ColorTransform</code>
* object. If the rectangle matches the boundaries of the bitmap image, this method transforms the color
* values of the entire image.
* @param rect A Rectangle object that defines the area of the image in which the ColorTransform object is applied.
* @param colorTransform A ColorTransform object that describes the color transformation values to apply.]]></haxe_doc>
</colorTransform>
<clone public="1" set="method">
<f a=""><c path="nme.display.BitmapData"/></f>
<haxe_doc>* Returns a new BitmapData object that is a clone of the original instance with an exact copy of the contained bitmap.
* @return A new BitmapData object that is identical to the original.</haxe_doc>
</clone>
<applyFilter public="1" set="method">
<f a="sourceBitmapData:sourceRect:destPoint:filter">
<c path="nme.display.BitmapData"/>
<c path="nme.geom.Rectangle"/>
<c path="nme.geom.Point"/>
<c path="nme.filters.BitmapFilter"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Takes a source image and a filter object and generates the filtered image.
*
* This method relies on the behavior of built-in filter objects, which determine the
* destination rectangle that is affected by an input source rectangle.
*
* After a filter is applied, the resulting image can be larger than the input image.
* For example, if you use a BlurFilter class to blur a source rectangle of (50,50,100,100)
* and a destination point of (10,10), the area that changes in the destination image is
* larger than (10,10,60,60) because of the blurring. This happens internally during the
* applyFilter() call.
*
* If the <code>sourceRect</code> parameter of the sourceBitmapData parameter is an
* interior region, such as (50,50,100,100) in a 200 x 200 image, the filter uses the source
* pixels outside the <code>sourceRect</code> parameter to generate the destination rectangle.
*
* If the BitmapData object and the object specified as the <code>sourceBitmapData</code>
* parameter are the same object, the application uses a temporary copy of the object to
* perform the filter. For best performance, avoid this situation.
*
* @param sourceBitmapData The input bitmap image to use. The source image can be a different BitmapData object or it can refer to the current BitmapData instance.
* @param sourceRect A rectangle that defines the area of the source image to use as input.
* @param destPoint The point within the destination image (the current BitmapData instance) that corresponds to the upper-left corner of the source rectangle.
* @param filter The filter object that you use to perform the filtering operation.]]></haxe_doc>
</applyFilter>
<width public="1" set="null">
<c path="Int"/>
<haxe_doc>* The width of the bitmap image in pixels.</haxe_doc>
</width>
<transparent public="1" set="null">
<e path="Bool"/>
<haxe_doc><![CDATA[* Defines whether the bitmap image supports per-pixel transparency. You can
* set this value only when you construct a BitmapData object by passing in
* <code>true</code> for the <code>transparent</code> parameter of the
* constructor. Then, after you create a BitmapData object, you can check
* whether it supports per-pixel transparency by determining if the value of
* the <code>transparent</code> property is <code>true</code>.]]></haxe_doc>
</transparent>
<rect public="1" set="null">
<c path="nme.geom.Rectangle"/>
<haxe_doc>* The rectangle that defines the size and location of the bitmap image. The
* top and left of the rectangle are 0; the width and height are equal to the
* width and height in pixels of the BitmapData object.</haxe_doc>
</rect>
<height public="1" set="null">
<c path="Int"/>
<haxe_doc>* The height of the bitmap image in pixels.</haxe_doc>
</height>
<new public="1" set="method">
<f a="width:height:?transparent:?fillColor">
<c path="Int"/>
<c path="Int"/>
<e path="Bool"/>
<t path="nme.display.BitmapInt32"/>
<e path="Void"/>
</f>
<haxe_doc><![CDATA[* Creates a BitmapData object with a specified width and height. If you specify a value for
* the <code>fillColor</code> parameter, every pixel in the bitmap is set to that color.
*
* By default, the bitmap is created as transparent, unless you pass the value <code>false</code>
* for the transparent parameter. After you create an opaque bitmap, you cannot change it
* to a transparent bitmap. Every pixel in an opaque bitmap uses only 24 bits of color channel
* information. If you define the bitmap as transparent, every pixel uses 32 bits of color
* channel information, including an alpha transparency channel.
*
* @param width The width of the bitmap image in pixels.
* @param height The height of the bitmap image in pixels.
* @param transparent Specifies whether the bitmap image supports per-pixel transparency. The default value is <code>true</code> (transparent). To create a fully transparent bitmap, set the value of the <code>transparent</code> parameter to <code>true</code> and the value of the <code>fillColor</code> parameter to 0x00000000 (or to 0). Setting the <code>transparent</code> property to <code>false</code> can result in minor improvements in rendering performance.
* @param fillColor A 32-bit ARGB color value that you use to fill the bitmap image area. The default value is 0xFFFFFFFF (solid white).]]></haxe_doc>
</new>
<haxe_doc><![CDATA[* The BitmapData class lets you work with the data (pixels) of a Bitmap
* object. You can use the methods of the BitmapData class to create
* arbitrarily sized transparent or opaque bitmap images and manipulate them
* in various ways at runtime. You can also access the BitmapData for a bitmap
* image that you load with the <code>nme.Assets</code> or
* <code>nme.display.Loader</code> classes.
*
* <p>This class lets you separate bitmap rendering operations from the
* internal display updating routines of NME. By manipulating a
* BitmapData object directly, you can create complex images without incurring
* the per-frame overhead of constantly redrawing the content from vector
* data.</p>
*
* <p>The methods of the BitmapData class support effects that are not
* available through the filters available to non-bitmap display objects.</p>
*
* <p>A BitmapData object contains an array of pixel data. This data can
* represent either a fully opaque bitmap or a transparent bitmap that
* contains alpha channel data. Either type of BitmapData object is stored as
* a buffer of 32-bit integers. Each 32-bit integer determines the properties
* of a single pixel in the bitmap.</p>
*
* <p>Each 32-bit integer is a combination of four 8-bit channel values (from
* 0 to 255) that describe the alpha transparency and the red, green, and blue
* (ARGB) values of the pixel. (For ARGB values, the most significant byte
* represents the alpha channel value, followed by red, green, and blue.)</p>
*
* <p>When you are targeting the Neko runtime, the pixel data is stored as an object
* with separate red, green, blue (RGB) and alpha (A) values. Unlike other targets,
* Neko uses 31-bit integers, so this necessary in order to store the full data for each
* pixel. You can use the <code>nme.display.BitmapInt32</class> object to represent
* either data format.</p>
*
* <p>The four channels (alpha, red, green, and blue) are represented as
* numbers when you use them with the <code>BitmapData.copyChannel()</code>
* method or the <code>DisplacementMapFilter.componentX</code> and
* <code>DisplacementMapFilter.componentY</code> properties, and these numbers
* are represented by the following constants in the BitmapDataChannel
* class:</p>
*
* <ul>
* <li><code>BitmapDataChannel.ALPHA</code></li>
* <li><code>BitmapDataChannel.RED</code></li>
* <li><code>BitmapDataChannel.GREEN</code></li>
* <li><code>BitmapDataChannel.BLUE</code></li>
* </ul>
*
* <p>You can attach BitmapData objects to a Bitmap object by using the
* <code>bitmapData</code> property of the Bitmap object.</p>
*
* <p>You can use a BitmapData object to fill a Graphics object by using the
* <code>Graphics.beginBitmapFill()</code> method.</p>
*
* <p>You can also use a BitmapData object to perform batch tile rendering
* using the <code>nme.display.Tilesheet</code> class.</p>
*
* <p>In Flash Player 10, the maximum size for a BitmapData object
* is 8,191 pixels in width or height, and the total number of pixels cannot
* exceed 16,777,215 pixels. (So, if a BitmapData object is 8,191 pixels wide,
* it can only be 2,048 pixels high.) In Flash Player 9 and earlier, the limitation
* is 2,880 pixels in height and 2,880 in width.</p>]]></haxe_doc>
</class>
<class path="nme.display.BitmapDataChannel" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/BitmapDataChannel.hx" extern="1">
<ALPHA public="1" get="inline" set="null" line="31" static="1">
<c path="Int"/>
<haxe_doc>* The alpha channel.</haxe_doc>
</ALPHA>
<BLUE public="1" get="inline" set="null" line="36" static="1">
<c path="Int"/>
<haxe_doc>* The blue channel.</haxe_doc>
</BLUE>
<GREEN public="1" get="inline" set="null" line="41" static="1">
<c path="Int"/>
<haxe_doc>* The green channel.</haxe_doc>
</GREEN>
<RED public="1" get="inline" set="null" line="46" static="1">
<c path="Int"/>
<haxe_doc>* The red channel.</haxe_doc>
</RED>
<haxe_doc><![CDATA[* The BitmapDataChannel class is an enumeration of constant values that
* indicate which channel to use: red, blue, green, or alpha transparency.
*
* <p>When you call some methods, you can use the bitwise OR operator
* (<code>|</code>) to combine BitmapDataChannel constants to indicate
* multiple color channels.</p>
*
* <p>The BitmapDataChannel constants are provided for use as values in the
* following:</p>
*
* <ul>
* <li>The <code>sourceChannel</code> and <code>destChannel</code>
* parameters of the <code>nme.display.BitmapData.copyChannel()</code>
* method</li>
* <li>The <code>channelOptions</code> parameter of the
* <code>nme.display.BitmapData.noise()</code> method</li>
* <li>The <code>nme.filters.DisplacementMapFilter.componentX</code> and
* <code>nme.filters.DisplacementMapFilter.componentY</code> properties</li>
* </ul>]]></haxe_doc>
</class>
<typedef path="nme.display.BitmapInt32" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/BitmapInt32.hx"><c path="Int"/></typedef>
<enum path="nme.display.BlendMode" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/BlendMode.hx">
<SUBTRACT><haxe_doc><![CDATA[* Subtracts the values of the constituent colors in the display object from
* the values of the background color, applying a floor of 0. This setting is
* commonly used for animating a darkening dissolve between two objects.
*
* <p>For example, if the display object has a pixel with an RGB value of
* 0xAA2233, and the background pixel has an RGB value of 0xDDA600, the
* resulting RGB value for the displayed pixel is 0x338400 (because 0xDD -
* 0xAA = 0x33, 0xA6 - 0x22 = 0x84, and 0x00 - 0x33 < 0x00).</p>]]></haxe_doc></SUBTRACT>
<SHADER><haxe_doc><![CDATA[* Uses a shader to define the blend between objects.
*
* <p>Setting the <code>blendShader</code> property to a Shader instance
* automatically sets the display object's <code>blendMode</code> property to
* <code>BlendMode.SHADER</code>. If the <code>blendMode</code> property is
* set to <code>BlendMode.SHADER</code> without first setting the
* <code>blendShader</code> property, the <code>blendMode</code> property is
* set to <code>BlendMode.NORMAL</code> instead. If the
* <code>blendShader</code> property is set (which sets the
* <code>blendMode</code> property to <code>BlendMode.SHADER</code>), then
* later the value of the <code>blendMode</code> property is changed, the
* blend mode can be reset to use the blend shader simply by setting the
* <code>blendMode</code> property to <code>BlendMode.SHADER</code>. The
* <code>blendShader</code> property does not need to be set again except to
* change the shader that's used to define the blend mode.</p>
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></SHADER>
<SCREEN><haxe_doc>* Multiplies the complement (inverse) of the display object color by the
* complement of the background color, resulting in a bleaching effect. This
* setting is commonly used for highlights or to remove black areas of the
* display object.</haxe_doc></SCREEN>
<OVERLAY><haxe_doc><![CDATA[* Adjusts the color of each pixel based on the darkness of the background.
* If the background is lighter than 50% gray, the display object and
* background colors are screened, which results in a lighter color. If the
* background is darker than 50% gray, the colors are multiplied, which
* results in a darker color. This setting is commonly used for shading
* effects.
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></OVERLAY>
<NORMAL><haxe_doc>* The display object appears in front of the background. Pixel values of the
* display object override the pixel values of the background. Where the
* display object is transparent, the background is visible.</haxe_doc></NORMAL>
<MULTIPLY><haxe_doc><![CDATA[* Multiplies the values of the display object constituent colors by the
* constituent colors of the background color, and normalizes by dividing by
* 0xFF, resulting in darker colors. This setting is commonly used for
* shadows and depth effects.
*
* <p>For example, if a constituent color (such as red) of one pixel in the
* display object and the corresponding color of the pixel in the background
* both have the value 0x88, the multiplied result is 0x4840. Dividing by
* 0xFF yields a value of 0x48 for that constituent color, which is a darker
* shade than the color of the display object or the color of the
* background.</p>]]></haxe_doc></MULTIPLY>
<LIGHTEN><haxe_doc><![CDATA[* Selects the lighter of the constituent colors of the display object and
* the colors of the background (the colors with the larger values). This
* setting is commonly used for superimposing type.
*
* <p>For example, if the display object has a pixel with an RGB value of
* 0xFFCC33, and the background pixel has an RGB value of 0xDDF800, the
* resulting RGB value for the displayed pixel is 0xFFF833 (because 0xFF >
* 0xDD, 0xCC < 0xF8, and 0x33 > 0x00 = 33).</p>
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></LIGHTEN>
<LAYER><haxe_doc><![CDATA[* Forces the creation of a transparency group for the display object. This
* means that the display object is precomposed in a temporary buffer before
* it is processed further. The precomposition is done automatically if the
* display object is precached by means of bitmap caching or if the display
* object is a display object container that has at least one child object
* with a <code>blendMode</code> setting other than <code>"normal"</code>.
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></LAYER>
<INVERT><haxe_doc>* Inverts the background.</haxe_doc></INVERT>
<HARDLIGHT><haxe_doc><![CDATA[* Adjusts the color of each pixel based on the darkness of the display
* object. If the display object is lighter than 50% gray, the display object
* and background colors are screened, which results in a lighter color. If
* the display object is darker than 50% gray, the colors are multiplied,
* which results in a darker color. This setting is commonly used for shading
* effects.
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></HARDLIGHT>
<ERASE><haxe_doc><![CDATA[* Erases the background based on the alpha value of the display object. This
* process requires that the <code>blendMode</code> property of the parent
* display object be set to <code>nme.display.BlendMode.LAYER</code>.
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></ERASE>
<DIFFERENCE><haxe_doc><![CDATA[* Compares the constituent colors of the display object with the colors of
* its background, and subtracts the darker of the values of the two
* constituent colors from the lighter value. This setting is commonly used
* for more vibrant colors.
*
* <p>For example, if the display object has a pixel with an RGB value of
* 0xFFCC33, and the background pixel has an RGB value of 0xDDF800, the
* resulting RGB value for the displayed pixel is 0x222C33 (because 0xFF -
* 0xDD = 0x22, 0xF8 - 0xCC = 0x2C, and 0x33 - 0x00 = 0x33).</p>]]></haxe_doc></DIFFERENCE>
<DARKEN><haxe_doc><![CDATA[* Selects the darker of the constituent colors of the display object and the
* colors of the background (the colors with the smaller values). This
* setting is commonly used for superimposing type.
*
* <p>For example, if the display object has a pixel with an RGB value of
* 0xFFCC33, and the background pixel has an RGB value of 0xDDF800, the
* resulting RGB value for the displayed pixel is 0xDDCC00 (because 0xFF >
* 0xDD, 0xCC < 0xF8, and 0x33 > 0x00 = 33).</p>
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></DARKEN>
<ALPHA><haxe_doc><![CDATA[* Applies the alpha value of each pixel of the display object to the
* background. This requires the <code>blendMode</code> property of the
* parent display object be set to
* <code>nme.display.BlendMode.LAYER</code>.
*
* <p>Not supported under GPU rendering.</p>]]></haxe_doc></ALPHA>
<ADD><haxe_doc><![CDATA[* Adds the values of the constituent colors of the display object to the
* colors of its background, applying a ceiling of 0xFF. This setting is
* commonly used for animating a lightening dissolve between two objects.
*
* <p>For example, if the display object has a pixel with an RGB value of
* 0xAAA633, and the background pixel has an RGB value of 0xDD2200, the
* resulting RGB value for the displayed pixel is 0xFFC833 (because 0xAA +
* 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8, and 0x33 + 0x00 = 0x33).</p>]]></haxe_doc></ADD>
<haxe_doc><![CDATA[* A class that provides constant values for visual blend mode effects. These
* constants are used in the following:
* <ul>
* <li> The <code>blendMode</code> property of the
* nme.display.DisplayObject class.</li>
* <li> The <code>blendMode</code> parameter of the <code>draw()</code>
* method of the nme.display.BitmapData class</li>
* </ul>]]></haxe_doc>
<meta><m n=":fakeEnum"><e>String</e></m></meta>
</enum>
<enum path="nme.display.CapsStyle" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/CapsStyle.hx">
<SQUARE><haxe_doc><![CDATA[* Used to specify square caps in the <code>caps</code> parameter of the
* <code>nme.display.Graphics.lineStyle()</code> method.]]></haxe_doc></SQUARE>
<ROUND><haxe_doc><![CDATA[* Used to specify round caps in the <code>caps</code> parameter of the
* <code>nme.display.Graphics.lineStyle()</code> method.]]></haxe_doc></ROUND>
<NONE><haxe_doc><![CDATA[* Used to specify no caps in the <code>caps</code> parameter of the
* <code>nme.display.Graphics.lineStyle()</code> method.]]></haxe_doc></NONE>
<haxe_doc><![CDATA[* The CapsStyle class is an enumeration of constant values that specify the
* caps style to use in drawing lines. The constants are provided for use as
* values in the <code>caps</code> parameter of the
* <code>nme.display.Graphics.lineStyle()</code> method. You can specify the
* following three types of caps:]]></haxe_doc>
<meta><m n=":fakeEnum"><e>String</e></m></meta>
</enum>
<class path="nme.display.InteractiveObject" params="" file="/Users/joshua/Development/Haxe/nme/nme/display/InteractiveObject.hx" extern="1">
<extends path="nme.display.DisplayObject"/>
<requestSoftKeyboard public="1">
<f a=""><e path="Bool"/></f>
<meta><m n=":require"><e>flash11</e></m></meta>
<haxe_doc><![CDATA[* Raises a virtual keyboard.
*
* <p>Calling this method focuses the InteractiveObject instance and raises
* the soft keyboard, if necessary. The <code>needsSoftKeyboard</code> must
* also be <code>true</code>. A keyboard is not raised if a hardware keyboard
* is available, or if the client system does not support virtual
* keyboards.</p>
*
* <p><b>Note:</b> This method is not supported in AIR applications on
* iOS.</p>
*
* @return A value of <code>true</code> means that the soft keyboard request
* was granted; <code>false</code> means that the soft keyboard was
* not raised.]]></haxe_doc>
</requestSoftKeyboard>
<tabIndex public="1">
<c path="Int"/>
<haxe_doc><![CDATA[* Specifies the tab ordering of objects in a SWF file. The
* <code>tabIndex</code> property is -1 by default, meaning no tab index is
* set for the object.
*
* <p>If any currently displayed object in the SWF file contains a
* <code>tabIndex</code> property, automatic tab ordering is disabled, and
* the tab ordering is calculated from the <code>tabIndex</code> properties
* of objects in the SWF file. The custom tab ordering includes only objects
* that have <code>tabIndex</code> properties.</p>
*
* <p>The <code>tabIndex</code> property can be a non-negative integer. The
* objects are ordered according to their <code>tabIndex</code> properties,
* in ascending order. An object with a <code>tabIndex</code> value of 1
* precedes an object with a <code>tabIndex</code> value of 2. Do not use the
* same <code>tabIndex</code> value for multiple objects.</p>
*
* <p>The custom tab ordering that the <code>tabIndex</code> property defines
* is <i>flat</i>. This means that no attention is paid to the hierarchical
* relationships of objects in the SWF file. All objects in the SWF file with
* <code>tabIndex</code> properties are placed in the tab order, and the tab
* order is determined by the order of the <code>tabIndex</code> values. </p>
*
* <p><b>Note:</b> To set the tab order for TLFTextField instances, cast the
* display object child of the TLFTextField as an InteractiveObject, then set
* the <code>tabIndex</code> property. For example: <pre
* xml:space="preserve">
* InteractiveObject(tlfInstance.getChildAt(1)).tabIndex = 3; </pre> To
* reverse the tab order from the default setting for three instances of a
* TLFTextField object (<code>tlfInstance1</code>, <code>tlfInstance2</code>
* and <code>tlfInstance3</code>), use: <pre xml:space="preserve">
* InteractiveObject(tlfInstance1.getChildAt(1)).tabIndex = 3;
* InteractiveObject(tlfInstance2.getChildAt(1)).tabIndex = 2;
* InteractiveObject(tlfInstance3.getChildAt(1)).tabIndex = 1; </pre> </p>]]></haxe_doc>
</tabIndex>
<tabEnabled public="1">
<e path="Bool"/>
<haxe_doc><![CDATA[* Specifies whether this object is in the tab order. If this object is in
* the tab order, the value is <code>true</code>; otherwise, the value is
* <code>false</code>. By default, the value is <code>false</code>, except
* for the following:
* <ul>
* <li>For a SimpleButton object, the value is <code>true</code>.</li>
* <li>For a TextField object with <code>type = "input"</code>, the value
* is <code>true</code>.</li>
* <li>For a Sprite object or MovieClip object with <code>buttonMode =
* true</code>, the value is <code>true</code>.</li>
* </ul>]]></haxe_doc>
</tabEnabled>
<softKeyboardInputAreaOfInterest public="1">
<c path="nme.geom.Rectangle"/>
<meta><m n=":require"><e>flash11</e></m></meta>
<haxe_doc><![CDATA[* Defines the area that should remain on-screen when a soft keyboard is
* displayed.
*
* <p>If the <code>needsSoftKeyboard</code> property of this
* InteractiveObject is <code>true</code>, then the runtime adjusts the
* display as needed to keep the object in view while the user types.
* Ordinarily, the runtime uses the object bounds obtained from the
* <code>DisplayObject.getBounds()</code> method. You can specify a different
* area using this <code>softKeyboardInputAreaOfInterest</code> property.</p>
*
* <p>Specify the <code>softKeyboardInputAreaOfInterest</code> in stage
* coordinates.</p>
*
* <p><b>Note:</b> On Android, the
* <code>softKeyboardInputAreaOfInterest</code> is not respected in landscape
* orientations.</p>]]></haxe_doc>
</softKeyboardInputAreaOfInterest>
<needsSoftKeyboard public="1">
<e path="Bool"/>
<meta><m n=":require"><e>flash11</e></m></meta>
<haxe_doc><![CDATA[* Specifies whether a virtual keyboard (an on-screen, software keyboard)
* should display when this InteractiveObject instance receives focus.
*
* <p>By default, the value is <code>false</code> and focusing an
* InteractiveObject instance does not raise a soft keyboard. If the
* <code>needsSoftKeyboard</code> property is set to <code>true</code>, the
* runtime raises a soft keyboard when the InteractiveObject instance is
* ready to accept user input. An InteractiveObject instance is ready to
* accept user input after a programmatic call to set the Stage
* <code>focus</code> property or a user interaction, such as a "tap." If the
* client system has a hardware keyboard available or does not support
* virtual keyboards, then the soft keyboard is not raised.</p>
*
* <p>The InteractiveObject instance dispatches
* <code>softKeyboardActivating</code>, <code>softKeyboardActivate</code>,
* and <code>softKeyboardDeactivate</code> events when the soft keyboard
* raises and lowers.</p>
*
* <p><b>Note:</b> This property is not supported in AIR applications on
* iOS.</p>]]></haxe_doc>
</needsSoftKeyboard>
<mouseEnabled public="1">
<e path="Bool"/>
<haxe_doc><![CDATA[* Specifies whether this object receives mouse, or other user input,
* messages. The default value is <code>true</code>, which means that by
* default any InteractiveObject instance that is on the display list
* receives mouse events or other user input events. If
* <code>mouseEnabled</code> is set to <code>false</code>, the instance does
* not receive any mouse events (or other user input events like keyboard
* events). Any children of this instance on the display list are not
* affected. To change the <code>mouseEnabled</code> behavior for all
* children of an object on the display list, use
* <code>nme.display.DisplayObjectContainer.mouseChildren</code>.
*
* <p> No event is dispatched by setting this property. You must use the
* <code>addEventListener()</code> method to create interactive
* functionality.</p>]]></haxe_doc>
</mouseEnabled>
<focusRect public="1">
<d/>
<haxe_doc><![CDATA[* Specifies whether this object displays a focus rectangle. It can take one
* of three values: <code>true</code>, <code>false</code>, or
* <code>null</code>. Values of <code>true</code> and <code>false</code> work
* as expected, specifying whether or not the focus rectangle appears. A
* value of <code>null</code> indicates that this object obeys the
* <code>stageFocusRect</code> property of the Stage.]]></haxe_doc>
</focusRect>
<doubleClickEnabled public="1">
<e path="Bool"/>
<haxe_doc><![CDATA[* Specifies whether the object receives <code>doubleClick</code> events. The
* default value is <code>false</code>, which means that by default an
* InteractiveObject instance does not receive <code>doubleClick</code>
* events. If the <code>doubleClickEnabled</code> property is set to
* <code>true</code>, the instance receives <code>doubleClick</code> events
* within its bounds. The <code>mouseEnabled</code> property of the
* InteractiveObject instance must also be set to <code>true</code> for the
* object to receive <code>doubleClick</code> events.
*
* <p>No event is dispatched by setting this property. You must use the
* <code>addEventListener()</code> method to add an event listener for the
* <code>doubleClick</code> event.</p>]]></haxe_doc>
</doubleClickEnabled>
<new public="1" set="method">
<f a=""><e path="Void"/></f>
<haxe_doc><![CDATA[* Calling the <code>new InteractiveObject()</code> constructor throws an
* <code>ArgumentError</code> exception. You can, however, call constructors
* for the following subclasses of InteractiveObject:
* <ul>
* <li><code>new SimpleButton()</code></li>
* <li><code>new TextField()</code></li>
* <li><code>new Loader()</code></li>
* <li><code>new Sprite()</code></li>
* <li><code>new MovieClip()</code></li>