You can access LoaderInfo objects in two ways:
contentLoaderInfo property of a nme.display.Loader
object - The contentLoaderInfo property is always available
for any Loader object. For a Loader object that has not called the
load() or loadBytes() method, or that has not
sufficiently loaded, attempting to access many of the properties of the
contentLoaderInfo property throws an error.loaderInfo property of a display object. The contentLoaderInfo property of a Loader object provides
information about the content that the Loader object is loading, whereas
the loaderInfo property of a DisplayObject provides
information about the root SWF file for that display object.
When you use a Loader object to load a display object(such as a SWF
file or a bitmap), the loaderInfo property of the display
object is the same as the contentLoaderInfo property of the
Loader object(DisplayObject.loaderInfo =
Loader.contentLoaderInfo). Because the instance of the main class of
the SWF file has no Loader object, the loaderInfo property is
the only way to access the LoaderInfo for the instance of the main class of
the SWF file.
The following diagram shows the different uses of the LoaderInfo
object - for the instance of the main class of the SWF file, for the
contentLoaderInfo property of a Loader object, and for the
loaderInfo property of a loaded object:
When a loading operation is not complete, some properties of the
contentLoaderInfo property of a Loader object are not
available. You can obtain some properties, such as
bytesLoaded, bytesTotal, url,
loaderURL, and applicationDomain. When the
loaderInfo object dispatches the init event, you
can access all properties of the loaderInfo object and the
loaded image or SWF file.
Note: All properties of LoaderInfo objects are read-only.
The EventDispatcher.dispatchEvent() method is not
applicable to LoaderInfo objects. If you call dispatchEvent()
on a LoaderInfo object, an IllegalOperationError exception is thrown.
object The object for which you want to get an associated LoaderInfo object.null when called in non-debugger builds(or when debugging is not enabled) or if the referenced object does not have an associated LoaderInfo object(such as some objects used by the AIR runtime).SecurityError The caller is not running in the local trusted sandbox.bytesTotal, all of the bytes are loaded.Before the first progress event is dispatched by this
LoaderInfo object's corresponding Loader object, bytesTotal
is 0. After the first progress event from the Loader object,
bytesTotal reflects the actual number of bytes to be
downloaded.
true;
otherwise, false. This property is set to true
if the child object has called the allowDomain() method to
grant permission to the parent domain or if a URL policy is loaded at the
child domain that grants permission to the parent domain. If child and
parent are in the same domain, this property is set to true.
For more information related to security, see the Flash Player Developer Center Topic: Security.
null if not
enough of the file has loaded in order to determine the type. The
following list gives the possible values:
"application/x-shockwave-flash""image/jpeg""image/gif""image/png"This value may differ from the actual frame rate in use. Flash Player or Adobe AIR only uses a single frame rate for all loaded SWF files at any one time, and this frame rate is determined by the nominal frame rate of the main SWF file. Also, the main frame rate may not be able to be achieved, depending on hardware, sound synchronization, and other factors.
LoaderInfo.url property has been truncated.
When the isURLInaccessible value is true the
LoaderInfo.url value is only the domain of the final URL from
which the content loaded. For example, the property is truncated if the
content is loaded from http://www.adobe.com/assets/hello.swf,
and the LoaderInfo.url property has the value
http://www.adobe.com. The isURLInaccessible
value is true only when all of the following are also true:
Loader.load() is from a different
domain than the content's final URL.Loader.load() does not have
permission to access the content. Permission is granted to access the
content the same way permission is granted for
BitmapData.draw(): call Security.allowDomain()
to access a SWF file(or for non-SWF file content, establish a policy file
and use the LoaderContext.checkPolicyFile property).Note: The isURLInaccessible property was added for
Flash Player 10.1 and AIR 2.0. However, this property is made available to
SWF files of all versions when the Flash runtime supports it. So, using
some authoring tools in "strict mode" causes a compilation error. To work
around the error use the indirect syntax
myLoaderInfo, or disable strict mode. If
you are using Flash Professional CS5 or Flex SDK 4.1, you can use and
compile this API for runtimes released before Flash Player 10.1 and AIR
2."isURLInaccessible"
For application content in AIR, the value of this property is always
false.
loaderInfo property of the instance
of the main class of the SWF file, no Loader object is associated.
You can use a for-in loop to extract all the names and
values from the parameters object.
The two sources of parameters are: the query string in the URL of the
main SWF file, and the value of the FlashVars HTML parameter
(this affects only the main SWF file).
The parameters property replaces the ActionScript 1.0 and
2.0 technique of providing SWF file parameters as properties of the main
timeline.
The value of the parameters property is null for Loader
objects that contain SWF files that use ActionScript 1.0 or 2.0. It is
only non-null for Loader objects that contain SWF files that use
ActionScript 3.0.
true;
otherwise, false. This property is set to true
if the parent object called the allowDomain() method to grant
permission to the child domain or if a URL policy file is loaded at the
parent domain granting permission to the child domain. If child and parent
are in the same domain, this property is set to true.
For more information related to security, see the Flash Player Developer Center Topic: Security.
true if they have the same origin domain; false
otherwise.
sharedEvents and send and receive events via this
object.SWFVersion.FLASH7 and SWFVersion.FLASH9.
Before the first progress event is dispatched by this
LoaderInfo object's corresponding Loader object, the value of the
url property might reflect only the initial URL specified in
the call to the load() method of the Loader object. After the
first progress event, the url property reflects
the media's final URL, after any redirects and relative URLs are
resolved.
In some cases, the value of the url property is truncated;
see the isURLInaccessible property for details.
type The type of event.useCapture Determines whether the listener works in the capture phase or the target and bubbling phases. If useCapture is set to true, the listener processes the event only during the capture phase and not in the target or bubbling phase. If useCapture is false, the listener processes the event only during the target or bubbling phase. To listen for the event in all three phases, call addEventListener twice, once with useCapture set to true, then again with useCapture set to false.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 n are processed before listeners of priority n-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.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. Class-level member functions are not subject to garbage collection, so you can set useWeakReference to true for class-level member functions without subjecting them to garbage collection. If you set useWeakReference to true 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.
ArgumentError The listener specified is not a function.After you successfully register an event listener, you cannot change
its priority through additional calls to addEventListener().
To change a listener's priority, you must first call
removeListener(). Then you can register the listener again
with the new priority level.
Keep in mind that after the listener is registered, subsequent calls to
addEventListener() with a different type or
useCapture value result in the creation of a separate
listener registration. For example, if you first register a listener with
useCapture set to true, it listens only during
the capture phase. If you call addEventListener() again using
the same listener object, but with useCapture set to
false, you have two separate listeners: one that listens
during the capture phase and another that listens during the target and
bubbling phases.
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.
If you no longer need an event listener, remove it by calling
removeEventListener(), 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 useWeakReference parameter is set to
true).
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.
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.
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).
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 target property cannot be changed, so you must create a new copy of the event for redispatching to work.true if the event was successfully dispatched. A value of false indicates failure or that preventDefault() was called on the event.Error The event dispatch recursion limit has been reached.dispatchEvent() method
is called.
type The type of event.true if a listener of the specified type is registered; false otherwise.willTrigger().
The difference between hasEventListener() and
willTrigger() is that hasEventListener()
examines only the object to which it belongs, whereas
willTrigger() examines the entire event flow for the event
specified by the type parameter.
When hasEventListener() is called from a LoaderInfo
object, only the listeners that the caller can access are considered.
type The type of event.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 removeEventListener() are required to remove both, one call with useCapture() set to true, and another call with useCapture() set to false.type The type of event.true if a listener of the specified type will be triggered; false otherwise.true 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.
The difference between the hasEventListener() and the
willTrigger() methods is that hasEventListener()
examines only the object to which it belongs, whereas the
willTrigger() method examines the entire event flow for the
event specified by the type parameter.
When willTrigger() is called from a LoaderInfo object,
only the listeners that the caller can access are considered.