avm2: Make event construction take an `EventData` parameter.

This also necessitated the introduction of a `FullScreenEvent` data type.

core/src/avm2.rs

@@ -46,7 +46,7 @@ mod vtable;
 pub use crate::avm2::activation::Activation;
 pub use crate::avm2::array::ArrayStorage;
 pub use crate::avm2::domain::Domain;
-pub use crate::avm2::events::Event;
+pub use crate::avm2::events::{Event, EventData};
 pub use crate::avm2::names::{Namespace, QName};
 pub use crate::avm2::object::{
     ArrayObject, ClassObject, Object, ScriptObject, SoundChannelObject, StageObject, TObject,

core/src/avm2/events.rs

@@ -7,8 +7,8 @@ use crate::avm2::value::Value;
 use crate::avm2::Error;
 use crate::display_object::{DisplayObject, TDisplayObject};
 use crate::string::AvmString;
-use fnv::FnvHashMap;
 use bitflags::bitflags;
+use fnv::FnvHashMap;
 use gc_arena::Collect;
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
@@ -63,6 +63,10 @@ bitflags! {
 #[collect(no_drop)]
 pub enum EventData<'gc> {
     Event,
+    FullScreenEvent {
+        full_screen: bool,
+        interactive: bool,
+    },
     MouseEvent {
         local_x: f64,
         local_y: f64,
@@ -110,7 +114,7 @@ pub struct Event<'gc> {
 
 impl<'gc> Event<'gc> {
     /// Construct a new event of a given type.
-    pub fn new<S>(event_type: S) -> Self
+    pub fn new<S>(event_type: S, event_data: EventData<'gc>) -> Self
     where
         S: Into<AvmString<'gc>>,
     {
@@ -123,7 +127,7 @@ impl<'gc> Event<'gc> {
             event_phase: EventPhase::AtTarget,
             target: None,
             event_type: event_type.into(),
-            event_data: EventData::Event,
+            event_data,
         }
     }
 

core/src/avm2/object/event_object.rs

@@ -1,7 +1,7 @@
 //! Object representation for events
 
 use crate::avm2::activation::Activation;
-use crate::avm2::events::Event;
+use crate::avm2::events::{Event, EventData};
 use crate::avm2::object::script_object::ScriptObjectData;
 use crate::avm2::object::{ClassObject, Object, ObjectPtr, TObject};
 use crate::avm2::value::Value;
@@ -22,7 +22,7 @@ pub fn event_allocator<'gc>(
         activation.context.gc_context,
         EventObjectData {
             base,
-            event: Event::new(""),
+            event: Event::new("", EventData::Event),
         },
     ))
     .into())

core/src/backend/audio.rs

@@ -1,6 +1,7 @@
 use crate::{
     avm1::SoundObject,
     avm2::Event as Avm2Event,
+    avm2::EventData as Avm2EventData,
     avm2::SoundChannelObject,
     display_object::{self, DisplayObject, MovieClip, TDisplayObject},
 };
@@ -313,7 +314,7 @@ impl<'gc> AudioManager<'gc> {
                     action_queue.queue_actions(
                         root,
                         crate::context::ActionType::Event2 {
-                            event: Avm2Event::new("soundComplete"),
+                            event: Avm2Event::new("soundComplete", Avm2EventData::Event),
                             target: object.into(),
                         },
                         false,

core/src/display_object.rs

@@ -3,8 +3,8 @@ use crate::avm1::{
 };
 use crate::avm2::{
     Activation as Avm2Activation, Avm2, Error as Avm2Error, Event as Avm2Event,
-    Namespace as Avm2Namespace, Object as Avm2Object, QName as Avm2QName, TObject as Avm2TObject,
+    EventData as Avm2EventData, Namespace as Avm2Namespace, Object as Avm2Object,
-    Value as Avm2Value,
+    QName as Avm2QName, TObject as Avm2TObject, Value as Avm2Value,
 };
 use crate::context::{RenderContext, UpdateContext};
 use crate::drawing::Drawing;
@@ -1027,7 +1027,7 @@ pub trait TDisplayObject<'gc>:
     /// Emit an `enterFrame` event on this DisplayObject and any children it
     /// may have.
     fn enter_frame(&self, context: &mut UpdateContext<'_, 'gc, '_>) {
-        let mut enter_frame_evt = Avm2Event::new("enterFrame");
+        let mut enter_frame_evt = Avm2Event::new("enterFrame", Avm2EventData::Event);
         enter_frame_evt.set_bubbles(false);
         enter_frame_evt.set_cancelable(false);
 
@@ -1073,7 +1073,7 @@ pub trait TDisplayObject<'gc>:
     /// Emit a `frameConstructed` event on this DisplayObject and any children it
     /// may have.
     fn frame_constructed(&self, context: &mut UpdateContext<'_, 'gc, '_>) {
-        let mut frame_constructed_evt = Avm2Event::new("frameConstructed");
+        let mut frame_constructed_evt = Avm2Event::new("frameConstructed", Avm2EventData::Event);
         frame_constructed_evt.set_bubbles(false);
         frame_constructed_evt.set_cancelable(false);
 
@@ -1098,7 +1098,7 @@ pub trait TDisplayObject<'gc>:
 
     /// Emit an `exitFrame` broadcast event.
     fn exit_frame(&self, context: &mut UpdateContext<'_, 'gc, '_>) {
-        let mut exit_frame_evt = Avm2Event::new("exitFrame");
+        let mut exit_frame_evt = Avm2Event::new("exitFrame", Avm2EventData::Event);
         exit_frame_evt.set_bubbles(false);
         exit_frame_evt.set_cancelable(false);
 

core/src/display_object/container.rs

@@ -1,6 +1,6 @@
 //! Container mix-in for display objects
 
-use crate::avm2::{Avm2, Event as Avm2Event, Value as Avm2Value};
+use crate::avm2::{Avm2, Event as Avm2Event, EventData as Avm2EventData, Value as Avm2Value};
 use crate::context::{RenderContext, UpdateContext};
 use crate::display_object::avm1_button::Avm1Button;
 use crate::display_object::movie_clip::MovieClip;
@@ -22,7 +22,7 @@ pub fn dispatch_removed_from_stage_event<'gc>(
     context: &mut UpdateContext<'_, 'gc, '_>,
 ) {
     if let Avm2Value::Object(object) = child.object2() {
-        let mut removed_evt = Avm2Event::new("removedFromStage");
+        let mut removed_evt = Avm2Event::new("removedFromStage", Avm2EventData::Event);
         removed_evt.set_bubbles(false);
         removed_evt.set_cancelable(false);
 
@@ -45,7 +45,7 @@ pub fn dispatch_removed_event<'gc>(
     context: &mut UpdateContext<'_, 'gc, '_>,
 ) {
     if let Avm2Value::Object(object) = child.object2() {
-        let mut removed_evt = Avm2Event::new("removed");
+        let mut removed_evt = Avm2Event::new("removed", Avm2EventData::Event);
         removed_evt.set_bubbles(true);
         removed_evt.set_cancelable(false);
 
@@ -65,7 +65,7 @@ pub fn dispatch_added_to_stage_event_only<'gc>(
     context: &mut UpdateContext<'_, 'gc, '_>,
 ) {
     if let Avm2Value::Object(object) = child.object2() {
-        let mut removed_evt = Avm2Event::new("addedToStage");
+        let mut removed_evt = Avm2Event::new("addedToStage", Avm2EventData::Event);
         removed_evt.set_bubbles(false);
         removed_evt.set_cancelable(false);
 
@@ -97,7 +97,7 @@ pub fn dispatch_added_event_only<'gc>(
     context: &mut UpdateContext<'_, 'gc, '_>,
 ) {
     if let Avm2Value::Object(object) = child.object2() {
-        let mut removed_evt = Avm2Event::new("added");
+        let mut removed_evt = Avm2Event::new("added", Avm2EventData::Event);
         removed_evt.set_bubbles(true);
         removed_evt.set_cancelable(false);
 

core/src/display_object/stage.rs

@@ -2,8 +2,9 @@
 
 use crate::avm1::Object as Avm1Object;
 use crate::avm2::{
-    Activation as Avm2Activation, Event as Avm2Event, Object as Avm2Object,
+    Activation as Avm2Activation, Event as Avm2Event, EventData as Avm2EventData,
-    ScriptObject as Avm2ScriptObject, StageObject as Avm2StageObject, Value as Avm2Value,
+    Object as Avm2Object, ScriptObject as Avm2ScriptObject, StageObject as Avm2StageObject,
+    Value as Avm2Value,
 };
 use crate::config::Letterbox;
 use crate::context::{RenderContext, UpdateContext};
@@ -559,7 +560,7 @@ impl<'gc> Stage<'gc> {
                 &[],
             );
         } else if let Avm2Value::Object(stage) = self.object2() {
-            let mut resized_event = Avm2Event::new("resize");
+            let mut resized_event = Avm2Event::new("resize", Avm2EventData::Event);
             resized_event.set_bubbles(false);
             resized_event.set_cancelable(false);
             if let Err(e) = crate::avm2::Avm2::dispatch_event(context, resized_event, stage) {
@@ -581,7 +582,13 @@ impl<'gc> Stage<'gc> {
                 &[self.is_fullscreen().into()],
             );
         } else if let Avm2Value::Object(stage) = self.object2() {
-            let mut full_screen_event = Avm2Event::new("fullScreen");
+            let mut full_screen_event = Avm2Event::new(
+                "fullScreen",
+                Avm2EventData::FullScreenEvent {
+                    full_screen: self.is_fullscreen(),
+                    interactive: true,
+                },
+            );
             full_screen_event.set_bubbles(false);
             full_screen_event.set_cancelable(false);