View source

class UncaughtErrorEvent

package openfl.events

extends ErrorEvent › TextEvent › Event

@:directlyUsed@:fileXml("tags=\"haxe,release\"")@:noDebug

Available on all platforms

An UncaughtErrorEvent object is dispatched by an instance of the UncaughtErrorEvents class when an uncaught error occurs. 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. The uncaught error event functionality is often described as a "global error handler." The UncaughtErrorEvents object that dispatches the event is associated with either a LoaderInfo object or a Loader object. Use the following properties to access an UncaughtErrorEvents instance:

When an uncaughtError event happens, even if the event is handled, execution does not continue in the call stack that caused the error. If the error is a synchronous error, any code remaining in the function where the error happened is not executed. Consequently, it is likely that when an uncaught error event happens, your application is in an unstable state. Since there can be many causes for an uncaught error, it is impossible to predict what functionality is available. For example, your application may be able to execute network operations or file operations. However, those operations aren't necessarily available.

When one SWF loads another, uncaughtError events bubble down and up again through the LoaderInfo heirarchy. For example, suppose A.swf loads B.swf using a Loader instance. If an uncaught error occurs in B.swf, an uncaughtError event is dispatched to LoaderInfo and Loader objects in the following sequence:

  1. (Capture phase) A.swf's LoaderInfo
  2. (Capture phase) Loader in A.swf
  3. (Target phase) B.swf's LoaderInfo
  4. (Bubble phase) Loader in A.swf
  5. (Bubble phase) A.swf's LoaderInfo

A Loader object's uncaughtErrorEvents property never dispatches an uncaughtErrorEvent in the target phase. It only dispatches the event in the capture and bubbling phases.

As with other event bubbling, calling stopPropagation() or stopImmediatePropagation() stops the event from being dispatched to any other listeners, with one important difference. A Loader object's UncaughtErrorEvents object is treated as a pair with the loaded SWF's LoaderInfo.uncaughtErrorEvents object for event propagation purposes. If a listener registered with one of those objects calls the stopPropagation() method, events are still dispatched to other listeners registered with that UncaughtErrorEvents object and to listeners registered with its partner UncaughtErrorEvents object before event propagation ends. The stopImmediatePropagation() method still prevents events from being dispatched to all additional listeners.

When content is running in a debugger version of the runtime, such as the debugger version of Flash Player or the AIR Debug Launcher (ADL), an uncaught error dialog appears when an uncaught error happens. For those runtime versions, the error dialog appears even when a listener is registered for the uncaughtError event. To prevent the dialog from appearing in that situation, call the UncaughtErrorEvent object's preventDefault() method.

If the content loaded by a Loader object is an AVM1 (ActionScript 2) SWF file, uncaught errors in the AVM1 SWF file do not result in an uncaughtError event. In addition, JavaScript errors in HTML content loaded in an HTMLLoader object (including a Flex HTML control) do not result in an uncaughtError event.

Static variables

@:value("uncaughtError")staticinlineread onlyUNCAUGHT_ERROR:EventType<UncaughtErrorEvent> = "uncaughtError"

Defines the value of the type property of an uncaughtError event object. This event has the following properties:

PropertyValue
bubblestrue
cancelabletrue; cancelling the event prevents the uncaught error dialog from appearing in debugger runtime versions
currentTargetThe object that is actively processing the Event object with an event listener.
errorThe uncaught error.
targetThe LoaderInfo object associated with the SWF where the error happened.
textText error message.

Constructor

@:value({ error : null, cancelable : true, bubbles : true })new(type:String, bubbles:Bool = true, cancelable:Bool = true, ?error:Dynamic)

Creates an UncaughtErrorEvent object that contains information about an uncaughtError event.

Parameters:

type

The type of the event.

bubbles

Determines whether the Event object participates in the bubbling stage of the event flow. Event listeners can access this information through the inherited bubbles property.

cancelable

Determines whether the Event object can be canceled. Event listeners can access this information through the inherited cancelable property.

error_in

The object associated with the error that was not caught or handled (an Error or ErrorEvent object under normal circumstances).

Variables

read onlyerror:Dynamic

The error object associated with the uncaught error. Typically, this object's data type is one of the following: An Error instance (or one of its subclasses), if the uncaught error is a synchronous error created by a throw statement, such as an error that could have been caught using a try..catch block An ErrorEvent instance (or one of its subclasses), if the uncaught error is an asynchronous error that dispatches an error event when the error happens

However, the error property can potentially be an object of any data type. Haxe does not require a throw statement to be used only with Error objects. For example, the following code is legal both at compile time and run time:

throw new Sprite();

If that throw statement is not caught by a try..catch block, the throw statement triggers an uncaughtError event. In that case, the error property of the UncaughtErrorEvent object that's dispatched is the Sprite object that's constructed in the throw statement.

Consequently, in your uncaughtError listener, you should check the data type of the error property. The following example demonstrates this check:

function uncaughtErrorHandler(event:UncaughtErrorEvent):Void {
	var message:String;
	if (Std.isOfType(event.error, Error)) {
		message = cast(event.error, Error).message;
	} else if (Std.isOfType(event.error, ErrorEvent)) {
		message = cast(event.error, ErrorEvent).text;
	} else {
		message = Std.string(event.error);
	}
}

If the error property contains an Error instance (or Error subclass), the available error information varies depending on the version of the runtime in which the content is running. The following functionality is only available when content is running in a debugger version of the runtime, such as the debugger version of Flash Player or the AIR Debug Launcher (ADL):

  • Error.getStackTrace() to get the call stack that led to the error. In non-debugger runtime versions, this method returns null. Note that call stack information is never available when the error property is an ErrorEvent instance.
  • Complete Error.message text. In non-debugger runtime versions, this property contains a short version of the error message, which is often a combination of the Error.errorID and Error.name properties.

All other properties and methods of the Error class are available in all runtime versions.

Methods

Inherited Variables

Defined by ErrorEvent

read onlyerrorID:Int

Contains the reference number associated with the specific error. For a custom ErrorEvent object, this number is the value from the id parameter supplied in the constructor.

Defined by TextEvent

text:String

For a textInput event, the character or sequence of characters entered by the user. For a link event, the text of the event attribute of the href attribute of the <a> tag.

Defined by Event

read onlybubbles:Bool

Indicates whether an event is a bubbling event. If the event can bubble, this value is true; otherwise it is false.

When an event occurs, it moves through the three phases of the event flow: the capture phase, which flows from the top of the display list hierarchy to the node just before the target node; the target phase, which comprises the target node; and the bubbling phase, which flows from the node subsequent to the target node back up the display list hierarchy.

Some events, such as the activate and unload events, do not have a bubbling phase. The bubbles property has a value of false for events that do not have a bubbling phase.

read onlycancelable:Bool

Indicates whether the behavior associated with the event can be prevented. If the behavior can be canceled, this value is true; otherwise it is false.

read onlycurrentTarget:Object

The object that is actively processing the Event object with an event listener. For example, if a user clicks an OK button, the current target could be the node containing that button or one of its ancestors that has registered an event listener for that event.

read onlyeventPhase:EventPhase

The current phase in the event flow. This property can contain the following numeric values:

read onlytarget:Object

The event target. This property contains the target node. For example, if a user clicks an OK button, the target node is the display list node containing that button.

read onlytype:String

The type of event. The type is case-sensitive.

Inherited Methods

Defined by Event

@:value({ p5 : null, p4 : null, p3 : null, p2 : null, p1 : null })formatToString(className:String, ?p1:String, ?p2:String, ?p3:String, ?p4:String, ?p5:String):String

A utility function for implementing the toString() method in custom OpenFL Event classes. Overriding the toString() method is recommended, but not required.

class PingEvent extends Event {
	var URL:String;

	public function new() {
		super();
	}

	public override function toString():String {
		return formatToString("PingEvent", "type", "bubbles", "cancelable", "eventPhase", "URL");
	}
}

Parameters:

className

The name of your custom Event class. In the previous example, the className parameter is PingEvent.

Returns:

The name of your custom Event class and the String value of your ...arguments parameter.

isDefaultPrevented():Bool

Checks whether the preventDefault() method has been called on the event. If the preventDefault() method has been called, returns true; otherwise, returns false.

Returns:

If preventDefault() has been called, returns true; otherwise, returns false.

preventDefault():Void

Cancels an event's default behavior if that behavior can be canceled. Many events have associated behaviors that are carried out by default. For example, if a user types a character into a text field, the default behavior is that the character is displayed in the text field. Because the TextEvent.TEXT_INPUT event's default behavior can be canceled, you can use the preventDefault() method to prevent the character from appearing. An example of a behavior that is not cancelable is the default behavior associated with the Event.REMOVED event, which is generated whenever Flash Player is about to remove a display object from the display list. The default behavior (removing the element) cannot be canceled, so the preventDefault() method has no effect on this default behavior. You can use the Event.cancelable property to check whether you can prevent the default behavior associated with a particular event. If the value of Event.cancelable is true, then preventDefault() can be used to cancel the event; otherwise, preventDefault() has no effect.

stopImmediatePropagation():Void

Prevents processing of any event listeners in the current node and any subsequent nodes in the event flow. This method takes effect immediately, and it affects event listeners in the current node. In contrast, the stopPropagation() method doesn't take effect until all the event listeners in the current node finish processing.

Note: This method does not cancel the behavior associated with this event; see preventDefault() for that functionality.

stopPropagation():Void

Prevents processing of any event listeners in nodes subsequent to the current node in the event flow. This method does not affect any event listeners in the current node (currentTarget). In contrast, the stopImmediatePropagation() method prevents processing of event listeners in both the current node and subsequent nodes. Additional calls to this method have no effect. This method can be called in any phase of the event flow.

Note: This method does not cancel the behavior associated with this event; see preventDefault() for that functionality.