avm2: Dispatch hover events while dragging

Author: uaua

core/src/player.rs

@@ -1628,15 +1628,15 @@ impl Player {
                 && !InteractiveObject::option_ptr_eq(cur_over_object, new_over_object)
             {
                 // If the mouse button is down, the object the user clicked on grabs the focus
-                // and fires "drag" events. Other objects are ignored.
+                // and fires "drag" events.
                 if context.input.is_mouse_down(MouseButton::Left) {
                     context.mouse_data.hovered = new_over_object;
                     if let Some(down_object) = context.mouse_data.pressed {
                         if InteractiveObject::option_ptr_eq(
                             context.mouse_data.pressed,
                             cur_over_object,
                         ) {
-                            // Dragged from outside the clicked object to the inside.
+                            // Dragged from inside the clicked object to the outside.
                             events.push((
                                 down_object,
                                 ClipEvent::DragOut {
@@ -1647,7 +1647,7 @@ impl Player {
                             context.mouse_data.pressed,
                             new_over_object,
                         ) {
-                            // Dragged from inside the clicked object to the outside.
+                            // Dragged from outside the clicked object to the inside.
                             events.push((
                                 down_object,
                                 ClipEvent::DragOver {
@@ -1656,6 +1656,36 @@ impl Player {
                             ));
                         }
                     }
+
+                    // While dragging, dispatch hover roll events only for AVM2 targets.
+                    if let Some(cur_over_object) = cur_over_object {
+                        if cur_over_object
+                            .as_displayobject()
+                            .movie()
+                            .is_action_script_3()
+                        {
+                            events.push((
+                                cur_over_object,
+                                ClipEvent::RollOut {
+                                    to: new_over_object,
+                                },
+                            ));
+                        }
+                    }
+                    if let Some(new_over_object) = new_over_object {
+                        if new_over_object
+                            .as_displayobject()
+                            .movie()
+                            .is_action_script_3()
+                        {
+                            events.push((
+                                new_over_object,
+                                ClipEvent::RollOver {
+                                    from: cur_over_object,
+                                },
+                            ));
+                        }
+                    }
                 } else {
                     // The mouse button is up, so fire rollover states for the object we are hovering over.
                     // Rolled out of the previous object.

tests/tests/swfs/avm1/rollover_while_dragging/input.json

@@ -0,0 +1,8 @@
+[
+  { "type": "MouseMove", "pos": [20, 20] },
+  { "type": "MouseDown", "pos": [20, 20], "btn": "Left" },
+  { "type": "MouseMove", "pos": [120, 40] },
+  { "type": "MouseMove", "pos": [195, 20] },
+  { "type": "MouseUp", "pos": [195, 20], "btn": "Left" },
+  { "type": "Wait" }
+]

tests/tests/swfs/avm1/rollover_while_dragging/output.txt

@@ -0,0 +1,2 @@
+startDrag
+stopDrag

tests/tests/swfs/avm1/rollover_while_dragging/test.as

@@ -0,0 +1,35 @@
+class Test {
+    static function main() {
+        var dragger:MovieClip = _root.createEmptyMovieClip("dragger", 1);
+        dragger.beginFill(0xCC3333, 100);
+        dragger.moveTo(0, 0);
+        dragger.lineTo(60, 0);
+        dragger.lineTo(60, 60);
+        dragger.lineTo(0, 60);
+        dragger.lineTo(0, 0);
+        dragger.endFill();
+        dragger._x = 10; dragger._y = 10;
+
+        var target:MovieClip = _root.createEmptyMovieClip("target", 2);
+        target.beginFill(0x33CC66, 100);
+        target.moveTo(0, 0);
+        target.lineTo(80, 0);
+        target.lineTo(80, 80);
+        target.lineTo(0, 80);
+        target.lineTo(0, 0);
+        target.endFill();
+        target._x = 110; target._y = 30;
+
+        target.onRollOver = function() { trace("OVER"); };
+        target.onRollOut  = function() { trace("OUT");  };
+
+        dragger.onPress = function() {
+            this.startDrag(false);
+            trace("startDrag");
+        };
+        dragger.onRelease = dragger.onReleaseOutside = function() {
+            this.stopDrag();
+            trace("stopDrag");
+        };
+    }
+}

tests/tests/swfs/avm1/rollover_while_dragging/test.swf

@@ -0,0 +1 @@
+num_ticks = 1

tests/tests/swfs/avm1/rollover_while_dragging/test.toml

@@ -0,0 +1,57 @@
+package {
+    import flash.display.MovieClip;
+    import flash.display.Sprite;
+    import flash.events.Event;
+    import flash.events.MouseEvent;
+    import flash.system.fscommand;
+
+    public class Test extends MovieClip {
+        private var dragger:MovieClip;
+        private var target:MovieClip;
+        private var sawOver:Boolean = false;
+
+        public function Test() {
+            addEventListener(Event.ADDED_TO_STAGE, onAdded);
+        }
+
+        private function onAdded(_:Event):void {
+            removeEventListener(Event.ADDED_TO_STAGE, onAdded);
+
+            dragger = new MovieClip();
+            dragger.graphics.beginFill(0xCC3333);
+            dragger.graphics.drawRect(0, 0, 100, 100);
+            dragger.graphics.endFill();
+            dragger.x = 0;
+            dragger.y = 0;
+            dragger.buttonMode = true;
+            addChild(dragger);
+
+            target = new MovieClip();
+            target.graphics.beginFill(0x33CC66);
+            target.graphics.drawRect(0, 0, 120, 120);
+            target.graphics.endFill();
+            target.x = 200;
+            target.y = 200;
+            addChild(target);
+
+            target.buttonMode = true;
+            target.mouseChildren = false;
+
+            target.addEventListener(MouseEvent.MOUSE_OVER, function(e:MouseEvent):void {
+                trace("OVER buttonDown=" + e.buttonDown);
+                sawOver = true;
+            });
+            target.addEventListener(MouseEvent.MOUSE_OUT, function(e:MouseEvent):void {
+                trace("OUT buttonDown=" + e.buttonDown);
+                if (sawOver) {
+                    fscommand("quit");
+                }
+            });
+
+            dragger.addEventListener(MouseEvent.MOUSE_DOWN, function(_:MouseEvent):void {
+                dragger.startDrag(false);
+                trace("startDrag");
+            });
+        }
+    }
+}

tests/tests/swfs/avm2/mouse_over_while_dragging/Test.as

@@ -0,0 +1,8 @@
+[
+  { "type": "MouseMove", "pos": [10, 10] },
+  { "type": "MouseDown", "pos": [10, 10], "btn": "Left" },
+  { "type": "MouseMove", "pos": [210, 210] },
+  { "type": "MouseMove", "pos": [360, 40] },
+  { "type": "MouseUp", "pos": [360, 40], "btn": "Left" },
+  { "type": "Wait" }
+]

tests/tests/swfs/avm2/mouse_over_while_dragging/input.json

@@ -0,0 +1,3 @@
+startDrag
+OVER buttonDown=true
+OUT buttonDown=true