The LoaderInfo class provides information about a loaded SWF file or a loaded image file(JPEG, GIF, or PNG). LoaderInfo objects are available for any display object. The information provided includes load progress, the URLs of the loader and loaded content, the number of bytes total for the media, and the nominal height and width of the media.

You can access LoaderInfo objects in two ways:

- The `contentLoaderInfo` property of a flash.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.
- The `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.

:event

  complete Dispatched when data has loaded successfully. In other words, it is dispatched when all the content has been downloaded and the loading has finished. The `complete` event is always dispatched after the `init` event. The `init` event is dispatched when the object is ready to access, though the content may still be downloading.

:event

  httpStatus Dispatched when a network request is made over HTTP and an HTTP status code can be detected.

:event

  init Dispatched when the properties and methods of a loaded SWF file are accessible and ready for use. The content, however, can still be downloading. A LoaderInfo object dispatches the `init` event when the following conditions exist:

                     * All properties and methods associated with the
                    loaded object and those associated with the LoaderInfo
                    object are accessible.
                     * The constructors for all child objects have
                    completed.
                     * All ActionScript code in the first frame of the
                    loaded SWF's main timeline has been executed.

                    For example, an `Event.INIT` is dispatched
                    when the first frame of a movie or animation is loaded.
                    The movie is then accessible and can be added to the
                    display list. The complete movie, however, can take
                    longer to download. The `Event.COMPLETE` is
                    only dispatched once the full movie is loaded.

                    The `init` event always precedes the
                    `complete` event.

:event

  ioError Dispatched when an input or output error occurs that causes a load operation to fail.

:event

  open Dispatched when a load operation starts.

:event

  progress Dispatched when data is received as the download operation progresses.

:event

  unload Dispatched by a LoaderInfo object whenever a loaded object is removed by using the `unload()` method of the Loader object, or when a second load is performed by the same Loader object and the original content is removed prior to the load beginning.

### Hierarchy

- EventDispatcher
  - LoaderInfo

### Implements

- IEventDispatcher

## Index

### Constructors

- constructor

### Properties

- applicationDomain
- bytes
- bytesLoaded
- bytesTotal
- childAllowsParent
- content
- contentType
- frameRate
- height
- loader
- loaderURL
- parameters
- parentAllowsChild
- sameDomain
- sharedEvents
- uncaughtErrorEvents
- url
- width

### Methods

- addEventListener
- dispatchEvent
- hasEventListener
- removeEventListener
- toString
- willTrigger

## Constructors

### constructor

- new LoaderInfo(target?: IEventDispatcher): LoaderInfo

- Inherited from EventDispatcher.constructor

  - Defined in lib/openfl/events/EventDispatcher.d.ts:50

  Aggregates an instance of the EventDispatcher class.

  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.

  #### Parameters

  - ##### Optional target: IEventDispatcher

    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.

  #### Returns LoaderInfo

## Properties

### applicationDomain

applicationDomain: ApplicationDomain

- Defined in lib/openfl/display/LoaderInfo.d.ts:138

When an external SWF file is loaded, all ActionScript 3.0 definitions contained in the loaded class are stored in the `applicationDomain` property.

All code in a SWF file is defined to exist in an application domain. The current application domain is where your main application runs. The system domain contains all application domains, including the current domain and all classes used by Flash Player or Adobe AIR.

All application domains, except the system domain, have an associated parent domain. The parent domain of your main application's `applicationDomain` is the system domain. Loaded classes are defined only when their parent doesn't already define them. You cannot override a loaded class definition with a newer definition.

For usage examples of application domains, see the "Client System Environment" chapter in the ActionScript 3.0 Developer's Guide.

throws

  SecurityError This security sandbox of the caller is not allowed to access this ApplicationDomain.

### bytes

bytes: ByteArray

- Defined in lib/openfl/display/LoaderInfo.d.ts:155

The bytes associated with a LoaderInfo object.

throws

  SecurityError If the object accessing this API is prevented from accessing the loaded object due to security restrictions. This situation can occur, for instance, when a Loader object attempts to access the `contentLoaderInfo.content` property and it is not granted security permission to access the loaded content.

                        For more information related to security, see the
                        Flash Player Developer Center Topic:
                        [Security](http://www.adobe.com/go/devnet_security_en).

### bytesLoaded

bytesLoaded: number

- Defined in lib/openfl/display/LoaderInfo.d.ts:161

The number of bytes that are loaded for the media. When this number equals the value of `bytesTotal`, all of the bytes are loaded.

### bytesTotal

bytesTotal: number

- Defined in lib/openfl/display/LoaderInfo.d.ts:172

The number of compressed bytes in the entire media file.

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.

### childAllowsParent

childAllowsParent: boolean

- Defined in lib/openfl/display/LoaderInfo.d.ts:189

Expresses the trust relationship from content(child) to the Loader (parent). If the child has allowed the parent access, `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.

throws

  Error Thrown if the file is not downloaded sufficiently to retrieve the requested information.

### content

content: DisplayObject

- Defined in lib/openfl/display/LoaderInfo.d.ts:210

The loaded object associated with this LoaderInfo object.

throws

  SecurityError If the object accessing this API is prevented from accessing the loaded object due to security restrictions. This situation can occur, for instance, when a Loader object attempts to access the `contentLoaderInfo.content` property and it is not granted security permission to access the loaded content.

                        For more information related to security, see the
                        Flash Player Developer Center Topic:
                        [Security](http://www.adobe.com/go/devnet_security_en).

### contentType

contentType: string

- Defined in lib/openfl/display/LoaderInfo.d.ts:223

The MIME type of the loaded file. The value is `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"`

### frameRate

frameRate: number

- Defined in lib/openfl/display/LoaderInfo.d.ts:240

The nominal frame rate, in frames per second, of the loaded SWF file. This number is often an integer, but need not be.

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.

throws

  Error If the file is not downloaded sufficiently to retrieve the requested information.

throws

  Error If the file is not a SWF file.

### height

height: number

- Defined in lib/openfl/display/LoaderInfo.d.ts:250

The nominal height of the loaded file. This value might differ from the actual height at which the content is displayed, since the loaded content or its parent display objects might be scaled.

throws

  Error If the file is not downloaded sufficiently to retrieve the requested information.

### loader

loader: Loader

- Defined in lib/openfl/display/LoaderInfo.d.ts:273

The Loader object associated with this LoaderInfo object. If this LoaderInfo object is the `loaderInfo` property of the instance of the main class of the SWF file, no Loader object is associated.

throws

  SecurityError If the object accessing this API is prevented from accessing the Loader object because of security restrictions. This can occur, for instance, when a loaded SWF file attempts to access its `loaderInfo.loader` property and it is not granted security permission to access the loading SWF file.

                        For more information related to security, see the
                        Flash Player Developer Center Topic:
                        [Security](http://www.adobe.com/go/devnet_security_en).

### loaderURL

loaderURL: string

- Defined in lib/openfl/display/LoaderInfo.d.ts:280

The URL of the SWF file that initiated the loading of the media described by this LoaderInfo object. For the instance of the main class of the SWF file, this URL is the same as the SWF file's own URL.

### parameters

parameters: any

- Defined in lib/openfl/display/LoaderInfo.d.ts:302

An object that contains name-value pairs that represent the parameters provided to the loaded SWF file.

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.

### parentAllowsChild

parentAllowsChild: boolean

- Defined in lib/openfl/display/LoaderInfo.d.ts:319

Expresses the trust relationship from Loader(parent) to the content (child). If the parent has allowed the child access, `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.

throws

  Error Thrown if the file is not downloaded sufficiently to retrieve the requested information.

### sameDomain

sameDomain: boolean

- Defined in lib/openfl/display/LoaderInfo.d.ts:333

Expresses the domain relationship between the loader and the content: `true` if they have the same origin domain; `false` otherwise.

throws

  Error Thrown if the file is not downloaded sufficiently to retrieve the requested information.

### sharedEvents

sharedEvents: EventDispatcher

- Defined in lib/openfl/display/LoaderInfo.d.ts:342

An EventDispatcher instance that can be used to exchange events across security boundaries. Even when the Loader object and the loaded content originate from security domains that do not trust one another, both can access `sharedEvents` and send and receive events via this object.

### uncaughtErrorEvents

uncaughtErrorEvents: UncaughtErrorEvents

- Defined in lib/openfl/display/LoaderInfo.d.ts:363

An object that dispatches an `uncaughtError` event when an unhandled error occurs in code in this LoaderInfo object's SWF file. An uncaught error happens when an error is thrown outside of any `try..catch` blocks or when an ErrorEvent object is dispatched with no registered listeners.

This property is created when the SWF associated with this LoaderInfo has finished loading. Until then the `uncaughtErrorEvents` property is `null`. In an ActionScript-only project, you can access this property during or after the execution of the constructor of the main class of the SWF file. For a Flex project, the `uncaughtErrorEvents` property is available after the `applicationComplete` event is dispatched.

### url

url: string

- Defined in lib/openfl/display/LoaderInfo.d.ts:379

The URL of the media being loaded.

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.

### width

width: number

- Defined in lib/openfl/display/LoaderInfo.d.ts:389

The nominal width of the loaded content. This value might differ from the actual width at which the content is displayed, since the loaded content or its parent display objects might be scaled.

throws

  Error If the file is not downloaded sufficiently to retrieve the requested information.

## Methods

### addEventListener

- addEventListener(type: string, listener: function, useCapture?: boolean, priority?: number, useWeakReference?: boolean): void

- Inherited from EventDispatcher.addEventListener

  - Defined in lib/openfl/events/EventDispatcher.d.ts:168

  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.

  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).

  throws

    ArgumentError The `listener` specified is not a function.

  #### Parameters

  - ##### type: string

    The type of event.

  - ##### listener: function

    - - (event: object): void

      - #### Parameters

        - ##### event: object

        #### Returns void

  - ##### Optional useCapture: boolean

    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`.

  - ##### Optional priority: number

    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.

  - ##### Optional useWeakReference: boolean

    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.

  #### Returns void

### dispatchEvent

- dispatchEvent(event: Event): boolean

- Inherited from EventDispatcher.dispatchEvent

  - Defined in lib/openfl/events/EventDispatcher.d.ts:186

  Dispatches an event into the event flow. The event target is the EventDispatcher object upon which the `dispatchEvent()` method is called.

  throws

    Error The event dispatch recursion limit has been reached.

  #### Parameters

  - ##### event: 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.

  #### Returns boolean

  A value of `true` if the event was successfully dispatched. A value of `false` indicates failure or that `preventDefault()` was called on the event.

### hasEventListener

- hasEventListener(type: string): boolean

- Inherited from EventDispatcher.hasEventListener

  - Defined in lib/openfl/events/EventDispatcher.d.ts:209

  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 `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.

  #### Parameters

  - ##### type: string

    The type of event.

  #### Returns boolean

  A value of `true` if a listener of the specified type is registered; `false` otherwise.

### removeEventListener

- removeEventListener(type: string, listener: function, useCapture?: boolean): void

- Inherited from EventDispatcher.removeEventListener

  - Defined in lib/openfl/events/EventDispatcher.d.ts:227

  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.

  #### Parameters

  - ##### type: string

    The type of event.

  - ##### listener: function

    - - (event: object): void

      - #### Parameters

        - ##### event: object

        #### Returns void

  - ##### Optional useCapture: boolean

    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`.

  #### Returns void

### toString

- toString(): string

- Inherited from EventDispatcher.toString

  - Defined in lib/openfl/events/EventDispatcher.d.ts:230

  #### Returns string

### willTrigger

- willTrigger(type: string): boolean

- Inherited from EventDispatcher.willTrigger

  - Defined in lib/openfl/events/EventDispatcher.d.ts:253

  Checks whether an event listener is registered with this EventDispatcher object or any of its ancestors for the specified event type. This method returns `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.

  #### Parameters

  - ##### type: string

    The type of event.

  #### Returns boolean

  A value of `true` if a listener of the specified type will be triggered; `false` otherwise.

Generated using TypeDoc