avm2: Migrate all Events to AS, remove EventData.

Author: adrian17

core/src/avm2.rs

@@ -3,7 +3,6 @@
 use crate::avm2::class::AllocatorFn;
 use crate::avm2::globals::SystemClasses;
 use crate::avm2::method::{Method, NativeMethodImpl};
-use crate::avm2::object::EventObject;
 use crate::avm2::script::{Script, TranslationUnit};
 use crate::context::UpdateContext;
 use crate::string::AvmString;
@@ -48,10 +47,10 @@ 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, EventData};
 pub use crate::avm2::names::{Namespace, QName};
 pub use crate::avm2::object::{
-    ArrayObject, ClassObject, Object, ScriptObject, SoundChannelObject, StageObject, TObject,
+    ArrayObject, ClassObject, EventObject, Object, ScriptObject, SoundChannelObject, StageObject,
+    TObject,
 };
 pub use crate::avm2::value::Value;
 
@@ -156,16 +155,12 @@ impl<'gc> Avm2<'gc> {
     /// The `bool` parameter reads true if the event was cancelled.
     pub fn dispatch_event(
         context: &mut UpdateContext<'_, 'gc, '_>,
-        event: Event<'gc>,
+        event: Object<'gc>,
         target: Object<'gc>,
     ) -> Result<bool, Error> {
         use crate::avm2::events::dispatch_event;
-
         let mut activation = Activation::from_nothing(context.reborrow());
-
-        let event_object = EventObject::from_event(&mut activation, event)?;
-
-        dispatch_event(&mut activation, target, event_object)
+        dispatch_event(&mut activation, target, event)
     }
 
     /// Add an object to the broadcast list.
@@ -209,10 +204,12 @@ impl<'gc> Avm2<'gc> {
     /// new broadcast type, you must add it to the `BROADCAST_WHITELIST` first.
     pub fn broadcast_event(
         context: &mut UpdateContext<'_, 'gc, '_>,
-        event: Event<'gc>,
+        event: Object<'gc>,
         on_type: ClassObject<'gc>,
     ) -> Result<(), Error> {
-        let event_name = event.event_type();
+        let base_event = event.as_event().unwrap(); // TODO: unwrap?
+        let event_name = base_event.event_type();
+        drop(base_event);
         if !BROADCAST_WHITELIST
             .iter()
             .any(|x| AvmString::from(*x) == event_name)
@@ -240,7 +237,7 @@ impl<'gc> Avm2<'gc> {
                 let mut activation = Activation::from_nothing(context.reborrow());
 
                 if object.is_of_type(on_type, &mut activation)? {
-                    Avm2::dispatch_event(&mut activation.context, event.clone(), object)?;
+                    Avm2::dispatch_event(&mut activation.context, event, object)?;
                 }
             }
         }

core/src/avm2/events.rs

@@ -5,11 +5,8 @@ use crate::avm2::names::{Namespace, QName};
 use crate::avm2::object::{Object, TObject};
 use crate::avm2::value::Value;
 use crate::avm2::Error;
-use crate::context::UpdateContext;
-use crate::display_object::{DisplayObject, InteractiveObject, TDisplayObject};
-use crate::events::KeyCode;
+use crate::display_object::TDisplayObject;
 use crate::string::AvmString;
-use bitflags::bitflags;
 use fnv::FnvHashMap;
 use gc_arena::Collect;
 use std::collections::BTreeMap;
@@ -45,101 +42,6 @@ pub enum PropagationMode {
     StopImmediate,
 }
 
-bitflags! {
-    /// Keyboard modifiers.
-    #[derive(Collect, Default)]
-    #[collect(require_static)]
-    pub struct KeyModifiers: u8 {
-        const CTRL = 0b00000001;
-        const ALT = 0b00000010;
-        const SHIFT = 0b00000100;
-        const COMMAND = 0b00001000;
-    }
-}
-
-impl KeyModifiers {
-    fn from_current_keys<'gc>(context: &mut UpdateContext<'_, 'gc, '_>) -> Self {
-        let mut keymods = KeyModifiers::default();
-
-        if context.input.is_key_down(KeyCode::Control) {
-            keymods.insert(KeyModifiers::CTRL);
-        }
-
-        if context.input.is_key_down(KeyCode::Alt) {
-            keymods.insert(KeyModifiers::ALT);
-        }
-
-        if context.input.is_key_down(KeyCode::Shift) {
-            keymods.insert(KeyModifiers::SHIFT);
-        }
-
-        //TODO: We don't have a UI keycode for ⌘.
-
-        keymods
-    }
-}
-
-/// The data for a dispatched event.
-///
-/// This roughly corresponds to properties provided on specific AS3 `Event`
-/// subclasses.
-#[derive(Clone, Collect, Debug)]
-#[collect(no_drop)]
-pub enum EventData<'gc> {
-    Empty,
-    Error {
-        text: AvmString<'gc>,
-        error_id: i32,
-    },
-    FullScreen {
-        full_screen: bool,
-        interactive: bool,
-    },
-    IOError {
-        text: AvmString<'gc>,
-        error_id: i32,
-    },
-    Mouse {
-        local_x: f64,
-        local_y: f64,
-        movement_x: f64,
-        movement_y: f64,
-        related_object: Option<InteractiveObject<'gc>>,
-        modifiers: KeyModifiers,
-        button_down: bool,
-        delta: i32,
-    },
-    SecurityError {
-        text: AvmString<'gc>,
-        error_id: i32,
-    },
-    Text {
-        text: AvmString<'gc>,
-    },
-}
-
-impl<'gc> EventData<'gc> {
-    pub fn mouse_event(
-        context: &mut UpdateContext<'_, 'gc, '_>,
-        target: DisplayObject<'gc>,
-        related_object: Option<InteractiveObject<'gc>>,
-        delta: i32,
-    ) -> Self {
-        let local_pos = target.global_to_local(*context.mouse_position);
-
-        Self::Mouse {
-            local_x: local_pos.0.to_pixels(),
-            local_y: local_pos.1.to_pixels(),
-            movement_x: 0.0, //TODO: Implement mouselocking.
-            movement_y: 0.0,
-            related_object,
-            modifiers: KeyModifiers::from_current_keys(context),
-            button_down: context.input.is_mouse_down(),
-            delta,
-        }
-    }
-}
-
 /// Represents data fields of an event that can be fired on an object that
 /// implements `IEventDispatcher`.
 #[derive(Clone, Collect, Debug)]
@@ -170,14 +72,11 @@ pub struct Event<'gc> {
 
     /// The name of the event being triggered.
     event_type: AvmString<'gc>,
-
-    /// The event's data set.
-    event_data: EventData<'gc>,
 }
 
 impl<'gc> Event<'gc> {
     /// Construct a new event of a given type.
-    pub fn new<S>(event_type: S, event_data: EventData<'gc>) -> Self
+    pub fn new<S>(event_type: S) -> Self
     where
         S: Into<AvmString<'gc>>,
     {
@@ -190,7 +89,6 @@ impl<'gc> Event<'gc> {
             event_phase: EventPhase::AtTarget,
             target: None,
             event_type: event_type.into(),
-            event_data,
         }
     }
 
@@ -272,18 +170,6 @@ impl<'gc> Event<'gc> {
     pub fn set_current_target(&mut self, current_target: Object<'gc>) {
         self.current_target = Some(current_target)
     }
-
-    pub fn event_data(&self) -> &EventData<'gc> {
-        &self.event_data
-    }
-
-    pub fn event_data_mut(&mut self) -> &mut EventData<'gc> {
-        &mut self.event_data
-    }
-
-    pub fn set_event_data(&mut self, event_data: EventData<'gc>) {
-        self.event_data = event_data;
-    }
 }
 
 /// A set of handlers organized by event type, priority, and order added.

core/src/avm2/globals.rs

@@ -452,11 +452,6 @@ pub fn load_player_globals<'gc>(
         flash::events::eventdispatcher::create_class(mc),
         script,
     )?;
-    class(
-        activation,
-        flash::events::eventphase::create_class(mc),
-        script,
-    )?;
 
     // package `flash.utils`
     avm2_system_class!(
@@ -691,59 +686,6 @@ pub fn load_player_globals<'gc>(
     // this call.
     load_playerglobal(activation, domain)?;
 
-    // These are event definitions, which need to be able to
-    // load "flash.events.Event", which is defined in our playerglobal.
-    // Therefore, they need to come after "load_playerglobal"
-    // FIXME: Convert all of these event classes to ActionScript,
-    // which will allow us to remove all of these calls.
-
-    avm2_system_class!(
-        mouseevent,
-        activation,
-        flash::events::mouseevent::create_class(mc),
-        script
-    );
-    avm2_system_class!(
-        textevent,
-        activation,
-        flash::events::textevent::create_class(mc),
-        script
-    );
-    avm2_system_class!(
-        errorevent,
-        activation,
-        flash::events::errorevent::create_class(mc),
-        script
-    );
-    avm2_system_class!(
-        securityerrorevent,
-        activation,
-        flash::events::securityerrorevent::create_class(mc),
-        script
-    );
-    avm2_system_class!(
-        ioerrorevent,
-        activation,
-        flash::events::ioerrorevent::create_class(mc),
-        script
-    );
-    class(
-        activation,
-        flash::events::keyboardevent::create_class(mc),
-        script,
-    )?;
-    class(
-        activation,
-        flash::events::progressevent::create_class(mc),
-        script,
-    )?;
-    avm2_system_class!(
-        fullscreenevent,
-        activation,
-        flash::events::fullscreenevent::create_class(mc),
-        script
-    );
-
     Ok(())
 }
 
@@ -803,6 +745,12 @@ fn load_playerglobal<'gc>(
         [
             ("flash.display", "Scene", scene),
             ("flash.events", "Event", event),
+            ("flash.events", "TextEvent", textevent),
+            ("flash.events", "ErrorEvent", errorevent),
+            ("flash.events", "SecurityErrorEvent", securityerrorevent),
+            ("flash.events", "IOErrorEvent", ioerrorevent),
+            ("flash.events", "MouseEvent", mouseevent),
+            ("flash.events", "FullScreenEvent", fullscreenevent),
         ]
     );
 

core/src/avm2/globals/flash/events.rs

@@ -1,14 +1,6 @@
 //! `flash.events` namespace
 
-pub mod errorevent;
 pub mod event;
 pub mod eventdispatcher;
-pub mod eventphase;
-pub mod fullscreenevent;
 pub mod ieventdispatcher;
-pub mod ioerrorevent;
-pub mod keyboardevent;
-pub mod mouseevent;
-pub mod progressevent;
-pub mod securityerrorevent;
-pub mod textevent;
+pub mod mouse_event;

core/src/avm2/globals/flash/events/ErrorEvent.as

@@ -0,0 +1,29 @@
+package flash.events {
+    public class ErrorEvent extends TextEvent {
+
+        public static const ERROR:String = "error";
+
+        private var _errorID:int;
+
+        public function ErrorEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, text:String = "", id:int = 0)
+        {
+            super(type,bubbles,cancelable,text);
+            this._errorID = id;
+        }
+
+        public function get errorID() : int
+        {
+            return this._errorID;
+        }
+
+        override public function clone() : Event
+        {
+            return new ErrorEvent(this.type,this.bubbles,this.cancelable,this.text,this._errorID);
+        }
+
+        override public function toString() : String
+        {
+            return this.formatToString("ErrorEvent","type","bubbles","cancelable","eventPhase","text");
+        }
+    }
+}

core/src/avm2/globals/flash/events/EventPhase.as

@@ -0,0 +1,7 @@
+package flash.events {
+    public final class EventPhase {
+        public static const CAPTURING_PHASE:uint = 1;
+        public static const AT_TARGET:uint = 2;
+        public static const BUBBLING_PHASE:uint = 3;
+    }
+}

core/src/avm2/globals/flash/events/FullScreenEvent.as

@@ -0,0 +1,38 @@
+package flash.events {
+    public class FullScreenEvent extends ActivityEvent {
+
+        public static const FULL_SCREEN:String = "fullScreen";
+        public static const FULL_SCREEN_INTERACTIVE_ACCEPTED:String = "fullScreenInteractiveAccepted";
+
+
+        private var _fullScreen:Boolean;
+        private var _interactive:Boolean;
+
+        public function FullScreenEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false, fullScreen:Boolean = false, interactive:Boolean = false)
+        {
+            super(type,bubbles,cancelable);
+            this._fullScreen = fullScreen;
+            this._interactive = interactive;
+        }
+
+        override public function clone() : Event
+        {
+            return new FullScreenEvent(this.type,this.bubbles,this.cancelable,this.fullScreen,this.interactive);
+        }
+
+        override public function toString() : String
+        {
+            return this.formatToString("FullScreenEvent","type","bubbles","cancelable","eventPhase","fullScreen","interactive");
+        }
+
+        public function get fullScreen() : Boolean
+        {
+            return this._fullScreen;
+        }
+
+        public function get interactive() : Boolean
+        {
+            return this._interactive;
+        }
+    }
+}