diff --git a/core/base/EventDispatcher.cpp b/core/base/EventDispatcher.cpp
index 17746d821e3c..c6f823b77fa2 100644
--- a/core/base/EventDispatcher.cpp
+++ b/core/base/EventDispatcher.cpp
@@ -975,6 +975,11 @@ void EventDispatcher::dispatchEvent(Event* event, bool forced)
         dispatchTouchEvent(static_cast<EventTouch*>(event));
         return;
     }
+    else if (event->getType() == Event::Type::MOUSE)
+    {
+        dispatchMouseEvent(static_cast<EventMouse*>(event));
+        return;
+    }
 
     auto listenerID = __getListenerID(event);
 
@@ -1207,6 +1212,86 @@ void EventDispatcher::dispatchTouchEvent(EventTouch* event)
     updateListeners(event);
 }
 
+void EventDispatcher::dispatchMouseEvent(EventMouse* event)
+{
+    sortEventListeners(EventListenerMouse::LISTENER_ID);
+
+    auto listeners = getListeners(EventListenerMouse::LISTENER_ID);
+
+    // If there aren't any mouse listeners, return directly.
+    if (nullptr == listeners)
+        return;
+
+    auto onMouseEvent = [&](EventListener* l) -> bool {  // Return true to break
+        EventListenerMouse* listener = static_cast<EventListenerMouse*>(l);
+
+        // Skip if the listener was removed.
+        if (!listener->_isRegistered)
+            return false;
+
+        event->setCurrentTarget(listener->_node);
+
+        bool isClaimed = false;
+
+        switch (event->getMouseEventType())
+        {
+        case EventMouse::MouseEventType::MOUSE_UP:
+            if (listener->onMouseUp)
+            {
+                isClaimed = listener->onMouseUp(event);
+            }
+            break;
+        case EventMouse::MouseEventType::MOUSE_DOWN:
+            if (listener->onMouseDown)
+            {
+                isClaimed = listener->onMouseDown(event);
+            }
+            break;
+        case EventMouse::MouseEventType::MOUSE_MOVE:
+            if (listener->onMouseMove)
+            {
+                isClaimed = listener->onMouseMove(event);
+            }
+            break;
+        case EventMouse::MouseEventType::MOUSE_SCROLL:
+            if (listener->onMouseScroll)
+            {
+                isClaimed = listener->onMouseScroll(event);
+            }
+            break;
+        case EventMouse::MouseEventType::MOUSE_NONE:
+            break;
+        default:
+            AXASSERT(false, "The type is invalid.");
+            break;
+        }
+        
+
+        // If the event was stopped, return directly.
+        if (event->isStopped())
+        {
+            updateListeners(event);
+            return true;
+        }
+
+        if (isClaimed && listener->_isRegistered && listener->_needSwallow)
+        {
+            return true;
+        }
+
+        return false;
+    };
+
+    //
+    dispatchTouchEventToListeners(listeners, onMouseEvent);
+    if (event->isStopped())
+    {
+        return;
+    }
+
+    updateListeners(event);
+}
+
 void EventDispatcher::updateListeners(Event* event)
 {
     AXASSERT(_inDispatch > 0, "If program goes here, there should be event in dispatch.");
diff --git a/core/base/EventDispatcher.h b/core/base/EventDispatcher.h
index 3e684bcc2bb2..36e3d0a11b89 100644
--- a/core/base/EventDispatcher.h
+++ b/core/base/EventDispatcher.h
@@ -48,6 +48,7 @@ namespace ax
 
 class Event;
 class EventTouch;
+class EventMouse;
 class Node;
 class EventCustom;
 class EventListenerCustom;
@@ -282,6 +283,10 @@ class AX_DLL EventDispatcher : public Object
      * mode. */
     void dispatchTouchEvent(EventTouch* event);
 
+    /** Mouse Scroll event needs to be processed different with other events since it needs support ALL_AT_ONCE and ONE_BY_NONE
+     * mode. */
+    void dispatchMouseEvent(EventMouse* event);
+
     /** Associates node with event listener */
     void associateNodeAndEventListener(Node* node, EventListener* listener);
 
diff --git a/core/base/EventListenerMouse.cpp b/core/base/EventListenerMouse.cpp
index ad64efd2fea9..0e67c03daf04 100644
--- a/core/base/EventListenerMouse.cpp
+++ b/core/base/EventListenerMouse.cpp
@@ -36,6 +36,16 @@ bool EventListenerMouse::checkAvailable()
     return true;
 }
 
+void EventListenerMouse::setSwallowMouse(bool needSwallow)
+{
+    _needSwallow = needSwallow;
+}
+
+bool EventListenerMouse::isSwallowMouse()
+{
+    return _needSwallow;
+}
+
 EventListenerMouse* EventListenerMouse::create()
 {
     auto ret = new EventListenerMouse();
@@ -60,6 +70,7 @@ EventListenerMouse* EventListenerMouse::clone()
         ret->onMouseDown   = onMouseDown;
         ret->onMouseMove   = onMouseMove;
         ret->onMouseScroll = onMouseScroll;
+        ret->_needSwallow  = _needSwallow;
     }
     else
     {
@@ -69,37 +80,16 @@ EventListenerMouse* EventListenerMouse::clone()
 }
 
 EventListenerMouse::EventListenerMouse()
-    : onMouseDown(nullptr), onMouseUp(nullptr), onMouseMove(nullptr), onMouseScroll(nullptr)
+    : onMouseDown(nullptr)
+    , onMouseUp(nullptr)
+    , onMouseMove(nullptr)
+    , onMouseScroll(nullptr)
+    , _needSwallow(false)
 {}
 
 bool EventListenerMouse::init()
 {
-    auto listener = [this](Event* event) {
-        auto mouseEvent = static_cast<EventMouse*>(event);
-        switch (mouseEvent->_mouseEventType)
-        {
-        case EventMouse::MouseEventType::MOUSE_DOWN:
-            if (onMouseDown != nullptr)
-                onMouseDown(mouseEvent);
-            break;
-        case EventMouse::MouseEventType::MOUSE_UP:
-            if (onMouseUp != nullptr)
-                onMouseUp(mouseEvent);
-            break;
-        case EventMouse::MouseEventType::MOUSE_MOVE:
-            if (onMouseMove != nullptr)
-                onMouseMove(mouseEvent);
-            break;
-        case EventMouse::MouseEventType::MOUSE_SCROLL:
-            if (onMouseScroll != nullptr)
-                onMouseScroll(mouseEvent);
-            break;
-        default:
-            break;
-        }
-    };
-
-    if (EventListener::init(Type::MOUSE, LISTENER_ID, listener))
+    if (EventListener::init(Type::MOUSE, LISTENER_ID, nullptr))
     {
         return true;
     }
diff --git a/core/base/EventListenerMouse.h b/core/base/EventListenerMouse.h
index 3d1174d9ae0a..b3f992da852b 100644
--- a/core/base/EventListenerMouse.h
+++ b/core/base/EventListenerMouse.h
@@ -54,17 +54,33 @@ class AX_DLL EventListenerMouse : public EventListener
      */
     static EventListenerMouse* create();
 
+    /** Whether or not to swall scrolls.
+     *
+     * @param needSwallow True if needs to swall scroll.
+     */
+    void setSwallowMouse(bool needSwallow);
+    /** Is swall scroll or not.
+     *
+     * @return True if needs to swall scroll.
+     */
+    bool isSwallowMouse();
+
     /// Overrides
     virtual EventListenerMouse* clone() override;
     virtual bool checkAvailable() override;
 
-    std::function<void(EventMouse* event)> onMouseDown;
-    std::function<void(EventMouse* event)> onMouseUp;
-    std::function<void(EventMouse* event)> onMouseMove;
-    std::function<void(EventMouse* event)> onMouseScroll;
+    std::function<bool(EventMouse* event)> onMouseDown;
+    std::function<bool(EventMouse* event)> onMouseUp;
+    std::function<bool(EventMouse* event)> onMouseMove;
+    std::function<bool(EventMouse* event)> onMouseScroll;
 
     EventListenerMouse();
     bool init();
+
+private:
+    bool _needSwallow;
+
+    friend class EventDispatcher;
 };
 
 }
diff --git a/core/base/EventMouse.h b/core/base/EventMouse.h
index 6840a11e85da..bd1706f2ef20 100644
--- a/core/base/EventMouse.h
+++ b/core/base/EventMouse.h
@@ -76,6 +76,12 @@ class AX_DLL EventMouse : public Event
      */
     EventMouse(MouseEventType mouseEventCode);
 
+    /** Get mouse event type.
+     *
+     * @return The type of the event.
+     */
+    MouseEventType getMouseEventType() const { return _mouseEventType; }
+
     /** Set mouse scroll data.
      *
      * @param scrollX The scroll data of x axis.
diff --git a/core/ui/UIScrollView.cpp b/core/ui/UIScrollView.cpp
index 8411845ce82e..3a01760a3d4e 100644
--- a/core/ui/UIScrollView.cpp
+++ b/core/ui/UIScrollView.cpp
@@ -87,6 +87,7 @@ ScrollView::ScrollView()
     , _scrollTime(DEFAULT_TIME_IN_SEC_FOR_SCROLL_TO_ITEM)
 {
     setTouchEnabled(true);
+    setMouseEnabled(true);
     _propagateTouchEvents = false;
 }
 
@@ -131,6 +132,7 @@ bool ScrollView::init()
         {
             initScrollBar();
         }
+
         return true;
     }
     return false;
@@ -1086,6 +1088,35 @@ void ScrollView::onTouchCancelled(Touch* touch, Event* unusedEvent)
     _isInterceptTouch = false;
 }
 
+bool ScrollView::onMouseScroll(Event* event)
+{
+    bool pass = Widget::onMouseScroll(event);
+
+    if(pass)
+    {
+        auto mouseEvent = static_cast<EventMouse*>(event);
+        float mouseFactor = 20.f;
+        Vec2 move;
+
+        if (_direction == Direction::HORIZONTAL)
+        {
+            move = Vec2(mouseEvent->getScrollY()*mouseFactor, 0.f);
+        }
+        else
+        {
+            move = Vec2(0.f, mouseEvent->getScrollY()*mouseFactor);
+        }
+
+        bool origBounce = _bounceEnabled;
+        _bounceEnabled = false;
+        scrollChildren(move);
+        _bounceEnabled = origBounce;
+        processScrollingEndedEvent();
+    }
+
+    return pass;
+}
+
 void ScrollView::update(float dt)
 {
     if (_autoScrolling)
diff --git a/core/ui/UIScrollView.h b/core/ui/UIScrollView.h
index f86fbd202da9..1b9baf437dc3 100644
--- a/core/ui/UIScrollView.h
+++ b/core/ui/UIScrollView.h
@@ -357,6 +357,7 @@ class AX_GUI_DLL ScrollView : public Layout
     void onTouchMoved(Touch* touch, Event* unusedEvent) override;
     void onTouchEnded(Touch* touch, Event* unusedEvent) override;
     void onTouchCancelled(Touch* touch, Event* unusedEvent) override;
+    bool onMouseScroll(Event* event) override;
     void update(float dt) override;
 
     /**
diff --git a/core/ui/UIWidget.cpp b/core/ui/UIWidget.cpp
index 0d4f434eab4c..b78fc6b6d805 100644
--- a/core/ui/UIWidget.cpp
+++ b/core/ui/UIWidget.cpp
@@ -176,6 +176,9 @@ Widget::Widget()
     , _ccEventCallback(nullptr)
     , _callbackType("")
     , _callbackName("")
+    , _mouseEnabled(false)
+    , _mouseListener(nullptr)
+    , _mouseHitted(false)
 {}
 
 Widget::~Widget()
@@ -606,6 +609,36 @@ bool Widget::isTouchEnabled() const
     return _touchEnabled;
 }
 
+void Widget::setMouseEnabled(bool enable)
+{
+    if (enable == _mouseEnabled)
+    {
+        return;
+    }
+    _mouseEnabled = enable;
+    if (_mouseEnabled)
+    {
+        _mouseListener = EventListenerMouse::create();
+        AX_SAFE_RETAIN(_mouseListener);
+        _mouseListener->setSwallowMouse(true);
+        _mouseListener->onMouseUp = AX_CALLBACK_1(Widget::onMouseUp, this);
+        _mouseListener->onMouseDown = AX_CALLBACK_1(Widget::onMouseDown, this);
+        _mouseListener->onMouseMove = AX_CALLBACK_1(Widget::onMouseMove, this);
+        _mouseListener->onMouseScroll = AX_CALLBACK_1(Widget::onMouseScroll, this);
+        _eventDispatcher->addEventListenerWithSceneGraphPriority(_mouseListener, this);
+    }
+    else
+    {
+        _eventDispatcher->removeEventListener(_mouseListener);
+        AX_SAFE_RELEASE_NULL(_mouseListener);
+    }
+}
+
+bool Widget::isMouseEnabled() const
+{
+    return _mouseEnabled;
+}
+
 bool Widget::isHighlighted() const
 {
     return _highlight;
@@ -919,6 +952,66 @@ void Widget::cancelUpEvent()
     this->release();
 }
 
+void Widget::setSwallowMouse(bool swallow)
+{
+    if (_mouseListener)
+    {
+        _mouseListener->setSwallowMouse(swallow);
+    }
+}
+
+bool Widget::isSwallowMouse() const
+{
+    if (_mouseListener)
+    {
+        return _mouseListener->isSwallowMouse();
+    }
+    return false;
+}
+
+bool Widget::onMouseEvent(Event* event)
+{
+    _mouseHitted = false;
+    if (isVisible() && isEnabled() && isAncestorsEnabled() && isAncestorsVisible(this))
+    {
+        auto scrollPosition = static_cast<EventMouse*>(event)->getLocation();
+        auto camera         = Camera::getVisitingCamera();
+        if (hitTest(scrollPosition, camera, nullptr))
+        {
+            if (isClippingParentContainsPoint(scrollPosition))
+            {
+                _mouseHitted = true;
+            }
+        }
+    }
+    if (!_mouseHitted)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool Widget::onMouseUp(Event* event)
+{
+    return onMouseEvent(event);
+}
+
+bool Widget::onMouseDown(Event* event)
+{
+    return onMouseEvent(event);
+}
+
+bool Widget::onMouseMove(Event* event)
+{
+    return onMouseEvent(event);
+}
+
+bool Widget::onMouseScroll(Event* event)
+{
+    return onMouseEvent(event);
+}
+
 void Widget::addTouchEventListener(const ccWidgetTouchCallback& callback)
 {
     this->_touchEventCallback = callback;
@@ -1207,6 +1300,7 @@ void Widget::copyProperties(Widget* widget)
     setVisible(widget->isVisible());
     setBright(widget->isBright());
     setTouchEnabled(widget->isTouchEnabled());
+    setMouseEnabled(widget->isMouseEnabled());
     setLocalZOrder(widget->getLocalZOrder());
     setTag(widget->getTag());
     setName(widget->getName());
diff --git a/core/ui/UIWidget.h b/core/ui/UIWidget.h
index 8069d5d8aff8..6c34d9c8d19d 100644
--- a/core/ui/UIWidget.h
+++ b/core/ui/UIWidget.h
@@ -41,6 +41,7 @@ namespace ax
 {
 
 class EventListenerTouchOneByOne;
+class EventListenerMouse;
 class Camera;
 
 namespace ui
@@ -200,6 +201,15 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
      */
     void setBrightStyle(BrightStyle style);
 
+    /**
+     * Sets whether the widget is mouse enabled.
+     *
+     * The default value is false, a widget is default to mouse disabled.
+     *
+     * @param enabled   True if the widget is mouse enabled, false if the widget is mouse disabled.
+     */
+    virtual void setMouseEnabled(bool enabled);
+
     /**
      * Determines if the widget is touch enabled
      *
@@ -207,6 +217,13 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
      */
     bool isTouchEnabled() const;
 
+    /**
+     * Determines if the widget is mouse enabled
+     *
+     * @return true if the widget is mouse enabled, false if the widget is mouse disabled.
+     */
+    bool isMouseEnabled() const;
+
     /**
      * Determines if the widget is highlighted
      *
@@ -481,6 +498,30 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
      */
     virtual void onTouchCancelled(Touch* touch, Event* unusedEvent);
 
+    /**
+     * A callback which will be called when a mouse up event is issued.
+     *@param event The mouse event info.
+     */
+    virtual bool onMouseUp(Event* event);
+
+    /**
+     * A callback which will be called when a mouse down event is issued.
+     *@param event The mouse event info.
+     */
+    virtual bool onMouseDown(Event* event);
+
+    /**
+     * A callback which will be called when a mouse move event is issued.
+     *@param event The mouse event info.
+     */
+    virtual bool onMouseMove(Event* event);
+
+    /**
+     * A callback which will be called when a mouse scroll event is issued.
+     *@param event The mouse event info.
+     */
+    virtual bool onMouseScroll(Event* event);
+
     /**
      * Sets a LayoutParameter to widget.
      *
@@ -602,6 +643,20 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
      */
     bool isSwallowTouches() const;
 
+     /**
+     * Toggle widget swallow mouse option.
+     * @brief Specify widget to swallow mouse or not
+     * @param swallow True to swallow mouse, false otherwise.
+     */
+    void setSwallowMouse(bool swallow);
+
+    /**
+     * Return whether the widget is swallowing mouse or not
+     * @return Whether mouse is swallowed.
+     */
+    bool isSwallowMouse() const;
+
+
     /**
      * Query whether widget is focused or not.
      *@return  whether the widget is focused or not
@@ -758,6 +813,8 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
     // call back function called widget's state changed to dark.
     virtual void onPressStateChangedToDisabled();
 
+    virtual bool onMouseEvent(Event* event);
+
     void pushDownEvent();
     void moveEvent();
 
@@ -788,6 +845,7 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
     bool _enabled;
     bool _bright;
     bool _touchEnabled;
+    bool _mouseEnabled;
     bool _highlight;
     bool _affectByClipping;
     bool _ignoreSize;
@@ -814,6 +872,9 @@ class AX_GUI_DLL Widget : public ProtectedNode, public LayoutParameterProtocol
     Vec2 _touchMovePosition;
     Vec2 _touchEndPosition;
 
+    bool _mouseHitted;
+    EventListenerMouse* _mouseListener;
+
     bool _flippedX;
     bool _flippedY;
 
diff --git a/extensions/ImGui/src/ImGui/ImGuiPresenter.cpp b/extensions/ImGui/src/ImGui/ImGuiPresenter.cpp
index 87f71cdd597f..02cf99616732 100644
--- a/extensions/ImGui/src/ImGui/ImGuiPresenter.cpp
+++ b/extensions/ImGui/src/ImGui/ImGuiPresenter.cpp
@@ -178,13 +178,9 @@ class ImGuiSceneEventTracker : public ImGuiEventTracker
         _trackLayer->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, _trackLayer);
 
         // add by halx99
-        auto stopAnyMouse = [=](EventMouse* event) {
-            if (ImGui::GetIO().WantCaptureMouse)
-            {
-                event->stopPropagation();
-            }
-        };
-        auto mouseListener         = EventListenerMouse::create();
+        auto stopAnyMouse = [=](EventMouse* event) -> bool { return ImGui::GetIO().WantCaptureMouse; };
+        auto mouseListener = EventListenerMouse::create();
+        mouseListener->setSwallowMouse(true);
         mouseListener->onMouseDown = mouseListener->onMouseUp = stopAnyMouse;
         _trackLayer->getEventDispatcher()->addEventListenerWithSceneGraphPriority(mouseListener, _trackLayer);
         scene->addChild(_trackLayer, INT_MAX);
@@ -242,13 +238,9 @@ class ImGuiGlobalEventTracker : public ImGuiEventTracker
         eventDispatcher->addEventListenerWithFixedPriority(_touchListener, highestPriority);
 
         // add by halx99
-        auto stopAnyMouse = [=](EventMouse* event) {
-            if (ImGui::GetIO().WantCaptureMouse)
-            {
-                event->stopPropagation();
-            }
-        };
-        _mouseListener              = utils::newInstance<EventListenerMouse>();
+        auto stopAnyMouse = [=](EventMouse* event) -> bool { return ImGui::GetIO().WantCaptureMouse; };
+        _mouseListener = utils::newInstance<EventListenerMouse>();
+        _mouseListener->setSwallowMouse(true);
         _mouseListener->onMouseDown = _mouseListener->onMouseUp = stopAnyMouse;
         eventDispatcher->addEventListenerWithFixedPriority(_mouseListener, highestPriority);
 #endif
diff --git a/extensions/fairygui/src/fairygui/event/InputProcessor.cpp b/extensions/fairygui/src/fairygui/event/InputProcessor.cpp
index aeb6af60d849..b475711dfe14 100644
--- a/extensions/fairygui/src/fairygui/event/InputProcessor.cpp
+++ b/extensions/fairygui/src/fairygui/event/InputProcessor.cpp
@@ -523,10 +523,10 @@ void InputProcessor::onTouchCancelled(Touch* touch, Event* /*unusedEvent*/)
     _activeProcessor = nullptr;
 }
 
-void InputProcessor::onMouseDown(ax::EventMouse * event)
+bool InputProcessor::onMouseDown(ax::EventMouse * event)
 {
     if (event->getMouseButton() == EventMouse::MouseButton::BUTTON_LEFT)
-        return;
+        return true;
 
     auto camera = Camera::getVisitingCamera();
     Vec2 pt = event->getLocation();
@@ -551,12 +551,14 @@ void InputProcessor::onMouseDown(ax::EventMouse * event)
     target->bubbleEvent(UIEventType::TouchBegin);
 
     _activeProcessor = nullptr;
+
+    return true;
 }
 
-void InputProcessor::onMouseUp(ax::EventMouse * event)
+bool InputProcessor::onMouseUp(ax::EventMouse * event)
 {
     if (event->getMouseButton() == EventMouse::MouseButton::BUTTON_LEFT)
-        return;
+        return true;
 
     auto camera = Camera::getVisitingCamera();
     Vec2 pt = event->getLocation();
@@ -615,16 +617,18 @@ void InputProcessor::onMouseUp(ax::EventMouse * event)
     ti->button = EventMouse::MouseButton::BUTTON_UNSET;
 
     _activeProcessor = nullptr;
+
+    return true;
 }
 
-void InputProcessor::onMouseMove(ax::EventMouse * event)
+bool InputProcessor::onMouseMove(ax::EventMouse * event)
 {
     TouchInfo* ti = getTouch(0);
     auto pt = event->getLocation();
     Vec2 npos = UIRoot->worldToRoot(pt);
     if (std::abs(ti->pos.x - npos.x) < 1
         && std::abs(ti->pos.y - npos.y) < 1)
-        return;
+        return true;
 
     auto camera = Camera::getVisitingCamera();
     GObject* target = _owner->hitTest(pt, camera);
@@ -664,9 +668,11 @@ void InputProcessor::onMouseMove(ax::EventMouse * event)
     }
 
     _activeProcessor = nullptr;
+
+    return true;
 }
 
-void InputProcessor::onMouseScroll(ax::EventMouse * event)
+bool InputProcessor::onMouseScroll(ax::EventMouse * event)
 {
     auto camera = Camera::getVisitingCamera();
     Vec2 pt = event->getLocation();
@@ -686,6 +692,8 @@ void InputProcessor::onMouseScroll(ax::EventMouse * event)
     ti->mouseWheelDelta = 0;
 
     _activeProcessor = nullptr;
+
+    return true;
 }
 
 void InputProcessor::onKeyDown(ax::EventKeyboard::KeyCode keyCode, ax::Event * event)
diff --git a/extensions/fairygui/src/fairygui/event/InputProcessor.h b/extensions/fairygui/src/fairygui/event/InputProcessor.h
index e1f89461dd9e..512995152add 100644
--- a/extensions/fairygui/src/fairygui/event/InputProcessor.h
+++ b/extensions/fairygui/src/fairygui/event/InputProcessor.h
@@ -43,10 +43,10 @@ class InputProcessor
     void onTouchEnded(ax::Touch * touch, ax::Event *);
     void onTouchCancelled(ax::Touch * touch, ax::Event *);
 
-    void onMouseDown(ax::EventMouse* event);
-    void onMouseUp(ax::EventMouse* event);
-    void onMouseMove(ax::EventMouse* event);
-    void onMouseScroll(ax::EventMouse* event);
+    bool onMouseDown(ax::EventMouse* event);
+    bool onMouseUp(ax::EventMouse* event);
+    bool onMouseMove(ax::EventMouse* event);
+    bool onMouseScroll(ax::EventMouse* event);
 
     void onKeyDown(ax::EventKeyboard::KeyCode keyCode, ax::Event*);
     void onKeyUp(ax::EventKeyboard::KeyCode keyCode, ax::Event*);
diff --git a/extensions/scripting/lua-bindings/manual/base/axlua_base_manual.cpp b/extensions/scripting/lua-bindings/manual/base/axlua_base_manual.cpp
index 4d8503604f7b..7817f84ae51f 100644
--- a/extensions/scripting/lua-bindings/manual/base/axlua_base_manual.cpp
+++ b/extensions/scripting/lua-bindings/manual/base/axlua_base_manual.cpp
@@ -5486,37 +5486,45 @@ static void cloneMouseHandler(const EventListenerMouse* src,
         {
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_DOWN:
         {
-            dst->onMouseDown = [=](Event* event) {
+            dst->onMouseDown = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)dst, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+
+                return true;
             };
         }
         break;
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_UP:
         {
-            dst->onMouseUp = [=](Event* event) {
+            dst->onMouseUp = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)dst, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+
+                return true;
             };
         }
         break;
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_MOVE:
         {
-            dst->onMouseMove = [=](Event* event) {
+            dst->onMouseMove = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)dst, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+
+                return true;
             };
         }
         break;
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_SCROLL:
         {
-            dst->onMouseScroll = [=](Event* event) {
+            dst->onMouseScroll = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)dst, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+
+                return true;
             };
         }
         break;
@@ -5622,19 +5630,21 @@ static int toaxlua_EventListenerMouse_registerScriptHandler(lua_State* tolua_S)
         {
             ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
 
-            self->onMouseDown = [=](Event* event) {
+            self->onMouseDown = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)self, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+                return true;
             };
         }
         break;
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_UP:
         {
-            self->onMouseUp = [=](Event* event) {
+            self->onMouseUp = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)self, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+                return true;
             };
 
             ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
@@ -5642,10 +5652,11 @@ static int toaxlua_EventListenerMouse_registerScriptHandler(lua_State* tolua_S)
         break;
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_MOVE:
         {
-            self->onMouseMove = [=](Event* event) {
+            self->onMouseMove = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)self, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+                return true;
             };
 
             ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
@@ -5653,10 +5664,11 @@ static int toaxlua_EventListenerMouse_registerScriptHandler(lua_State* tolua_S)
         break;
         case ScriptHandlerMgr::HandlerType::EVENT_MOUSE_SCROLL:
         {
-            self->onMouseScroll = [=](Event* event) {
+            self->onMouseScroll = [=](Event* event) -> bool {
                 LuaEventMouseData mouseData(event);
                 BasicScriptData data((void*)self, (void*)&mouseData);
                 LuaEngine::getInstance()->handleEvent(type, (void*)&data);
+                return true;
             };
 
             ScriptHandlerMgr::getInstance()->addObjectHandler((void*)self, handler, type);
diff --git a/templates/cpp/Source/MainScene.cpp b/templates/cpp/Source/MainScene.cpp
index 8190a5abb272..a247b0ecc989 100644
--- a/templates/cpp/Source/MainScene.cpp
+++ b/templates/cpp/Source/MainScene.cpp
@@ -166,28 +166,32 @@ void MainScene::onTouchesEnded(const std::vector<ax::Touch*>& touches, ax::Event
     }
 }
 
-void MainScene::onMouseDown(Event* event)
+bool MainScene::onMouseDown(Event* event)
 {
     EventMouse* e = static_cast<EventMouse*>(event);
     // AXLOGD("onMouseDown detected, Key: %d", static_cast<int>(e->getMouseButton()));
+    return true;
 }
 
-void MainScene::onMouseUp(Event* event)
+bool MainScene::onMouseUp(Event* event)
 {
     EventMouse* e = static_cast<EventMouse*>(event);
     AXLOGD("onMouseUp detected, Key: %d", static_cast<int>(e->getMouseButton()));
+    return true;
 }
 
-void MainScene::onMouseMove(Event* event)
+bool MainScene::onMouseMove(Event* event)
 {
     EventMouse* e = static_cast<EventMouse*>(event);
     // AXLOGD("onMouseMove detected, X:{}  Y:{}", e->getCursorX(), e->getCursorY());
+    return true;
 }
 
-void MainScene::onMouseScroll(Event* event)
+bool MainScene::onMouseScroll(Event* event)
 {
     EventMouse* e = static_cast<EventMouse*>(event);
     // AXLOGD("onMouseScroll detected, X:{}  Y:{}", e->getScrollX(), e->getScrollY());
+    return true;
 }
 
 void MainScene::onKeyPressed(EventKeyboard::KeyCode code, Event* event)
diff --git a/templates/cpp/Source/MainScene.h b/templates/cpp/Source/MainScene.h
index 0e54b2953d4b..91389a11a6a2 100644
--- a/templates/cpp/Source/MainScene.h
+++ b/templates/cpp/Source/MainScene.h
@@ -50,10 +50,10 @@ class MainScene : public ax::Scene
     void onTouchesEnded(const std::vector<ax::Touch*>& touches, ax::Event* event);
 
     // mouse
-    void onMouseDown(ax::Event* event);
-    void onMouseUp(ax::Event* event);
-    void onMouseMove(ax::Event* event);
-    void onMouseScroll(ax::Event* event);
+    bool onMouseDown(ax::Event* event);
+    bool onMouseUp(ax::Event* event);
+    bool onMouseMove(ax::Event* event);
+    bool onMouseScroll(ax::Event* event);
 
     // Keyboard
     void onKeyPressed(ax::EventKeyboard::KeyCode code, ax::Event* event);
diff --git a/tests/cpp-tests/Source/BaseTest.cpp b/tests/cpp-tests/Source/BaseTest.cpp
index 84fbef1d5c1e..aef2b3d1018c 100644
--- a/tests/cpp-tests/Source/BaseTest.cpp
+++ b/tests/cpp-tests/Source/BaseTest.cpp
@@ -94,7 +94,7 @@ class TestCustomTableView : public TableView
         ScrollView::onTouchEnded(touch, event);
     }
 
-    void onMouseScroll(Event* event)
+    bool onMouseScroll(Event* event)
     {
         auto mouseEvent = static_cast<EventMouse*>(event);
         float moveY     = mouseEvent->getScrollY() * 20;
@@ -114,6 +114,8 @@ class TestCustomTableView : public TableView
             offset.y = maxOffset.y;
         }
         this->setContentOffset(offset);
+
+        return true;
     }
 
 protected:
diff --git a/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.cpp b/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.cpp
index 7166c3f6caaa..d91c130470a2 100644
--- a/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.cpp
+++ b/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.cpp
@@ -187,7 +187,7 @@ void Box2DTestBed::onKeyReleased(EventKeyboard::KeyCode code, Event* event)
     m_test->KeyboardUp((static_cast<int>(code) - 59));  // its a bad hack!
 }
 
-void Box2DTestBed::onMouseDown(Event* event)
+bool Box2DTestBed::onMouseDown(Event* event)
 {
     EventMouse* e = (EventMouse*)event;
     button[(int)EventMouse::MouseButton::BUTTON_LEFT]   = false;
@@ -205,16 +205,20 @@ void Box2DTestBed::onMouseDown(Event* event)
         button[(int)EventMouse::MouseButton::BUTTON_MIDDLE] = true;
         break;
     }
+
+    return true;
 }
 
-void Box2DTestBed::onMouseUp(Event* event)
+bool Box2DTestBed::onMouseUp(Event* event)
 {
     button[(int)EventMouse::MouseButton::BUTTON_LEFT]   = false;
     button[(int)EventMouse::MouseButton::BUTTON_RIGHT]  = false;
     button[(int)EventMouse::MouseButton::BUTTON_MIDDLE] = false;
+
+    return true;
 }
 
-void Box2DTestBed::onMouseMove(Event* event)
+bool Box2DTestBed::onMouseMove(Event* event)
 {
     EventMouse* e = (EventMouse*)event;
     auto pt = e->getLocation();
@@ -226,12 +230,16 @@ void Box2DTestBed::onMouseMove(Event* event)
         (pos.y < oldPos.y) ? g_debugDraw.debugNodeOffset.y -= 2 : g_debugDraw.debugNodeOffset.y += 2;
     }
     oldPos = pos;
+
+    return true;
 }
 
-void Box2DTestBed::onMouseScroll(Event* event)
+bool Box2DTestBed::onMouseScroll(Event* event)
 {
     EventMouse* e = (EventMouse*)event;
     g_debugDraw.mRatio += e->getScrollY();
+
+    return true;
 }
 
 void Box2DTestBed::onEnter()
diff --git a/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.h b/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.h
index 027a1e887252..0657e8c93912 100644
--- a/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.h
+++ b/tests/cpp-tests/Source/Box2DTestBed/Box2DTestBed.h
@@ -73,10 +73,10 @@ class Box2DTestBed : public TestCase, ax::Layer
     void onKeyPressed(ax::EventKeyboard::KeyCode code, ax::Event* event);
     void onKeyReleased(ax::EventKeyboard::KeyCode code, ax::Event* event);
 
-    void onMouseDown(ax::Event* event);
-    void onMouseUp(ax::Event* event);
-    void onMouseMove(ax::Event* event);
-    void onMouseScroll(ax::Event* event);
+    bool onMouseDown(ax::Event* event);
+    bool onMouseUp(ax::Event* event);
+    bool onMouseMove(ax::Event* event);
+    bool onMouseScroll(ax::Event* event);
 
     ax::EventListenerTouchOneByOne* _touchListener;
     ax::EventListenerKeyboard* _keyboardListener;
diff --git a/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.cpp b/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.cpp
index 4166ffdd8dd9..a7616ac55001 100644
--- a/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.cpp
+++ b/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.cpp
@@ -425,7 +425,7 @@ void ChipmunkTestBed::onEnter()
     label->setString("");
 }
 
-void ChipmunkTestBed::onMouseDown(Event* event)
+bool ChipmunkTestBed::onMouseDown(Event* event)
 {
     EventMouse* e = (EventMouse*)event;
 
@@ -461,9 +461,11 @@ void ChipmunkTestBed::onMouseDown(Event* event)
         ChipmunkDemoRightDown  = cpTrue;
         ChipmunkDemoRightClick = cpTrue;
     }
+
+    return true;
 }
 
-void ChipmunkTestBed::onMouseUp(Event* event)
+bool ChipmunkTestBed::onMouseUp(Event* event)
 {
     EventMouse* e = (EventMouse*)event;
     mousePresses  = false;
@@ -476,9 +478,11 @@ void ChipmunkTestBed::onMouseUp(Event* event)
     ChipmunkDemoLeftDown   = cpFalse;
     ChipmunkDemoRightDown  = cpFalse;
     ChipmunkDemoRightClick = cpFalse;
+
+    return true;
 }
 
-void ChipmunkTestBed::onMouseMove(Event* event)
+bool ChipmunkTestBed::onMouseMove(Event* event)
 {
     EventMouse* e = (EventMouse*)event;
     auto pt = e->getLocation();
@@ -486,6 +490,8 @@ void ChipmunkTestBed::onMouseMove(Event* event)
     ChipmunkDemoMouse.y = pt.y - physicsDebugNodeOffset.y;
 
     cpBodySetPosition(mouse_body, ChipmunkDemoMouse);
+
+    return true;
 }
 
 void ChipmunkTestBed::updateInit(ChipmunkDemo tt)
diff --git a/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.h b/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.h
index 11f40b310e5a..572c6a32828f 100644
--- a/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.h
+++ b/tests/cpp-tests/Source/ChipmunkTestBed/ChipmunkTestBed.h
@@ -48,9 +48,9 @@ class ChipmunkTestBed : public TestCase
     void update(float dt) override;
     virtual void initPhysics();
 
-    void onMouseDown(ax::Event* event);
-    void onMouseUp(ax::Event* event);
-    void onMouseMove(ax::Event* event);
+    bool onMouseDown(ax::Event* event);
+    bool onMouseUp(ax::Event* event);
+    bool onMouseMove(ax::Event* event);
     void DrawInfo();
     void updateInit(ChipmunkDemo tt);
 
diff --git a/tests/cpp-tests/Source/InputTest/MouseTest.cpp b/tests/cpp-tests/Source/InputTest/MouseTest.cpp
index 3b156e176546..494d4de319c3 100644
--- a/tests/cpp-tests/Source/InputTest/MouseTest.cpp
+++ b/tests/cpp-tests/Source/InputTest/MouseTest.cpp
@@ -73,35 +73,43 @@ MouseEventTest::~MouseEventTest()
     _eventDispatcher->removeEventListener(_mouseListener);
 }
 
-void MouseEventTest::onMouseDown(Event* event)
+bool MouseEventTest::onMouseDown(Event* event)
 {
     EventMouse* e   = (EventMouse*)event;
     std::string str = "Mouse Down detected, Key: ";
     str += tostr(static_cast<int>(e->getMouseButton()));
     _labelAction->setString(str.c_str());
+
+    return true;
 }
 
-void MouseEventTest::onMouseUp(Event* event)
+bool MouseEventTest::onMouseUp(Event* event)
 {
     EventMouse* e   = (EventMouse*)event;
     std::string str = "Mouse Up detected, Key: ";
     str += tostr(static_cast<int>(e->getMouseButton()));
     _labelAction->setString(str.c_str());
+
+    return true;
 }
 
-void MouseEventTest::onMouseMove(Event* event)
+bool MouseEventTest::onMouseMove(Event* event)
 {
     EventMouse* e   = (EventMouse*)event;
     auto loc = e->getLocation();
     std::string str = fmt::format("MousePosition:({},{})", loc.x, loc.y);
     _labelPosition->setString(str);
+
+    return true;
 }
 
-void MouseEventTest::onMouseScroll(Event* event)
+bool MouseEventTest::onMouseScroll(Event* event)
 {
     EventMouse* e   = (EventMouse*)event;
     std::string str = fmt::format("Mouse Scroll detected, X:{} Y:{}", e->getScrollX(), e->getScrollY());
     _labelAction->setString(str.c_str());
+
+    return true;
 }
 
 std::string MouseEventTest::title() const
@@ -124,9 +132,15 @@ HideMouseTest::HideMouseTest()
 {
 
     _lis              = EventListenerMouse::create();
-    _lis->onMouseDown = [](Event* e) { Director::getInstance()->getGLView()->setCursorVisible(false); };
-
-    _lis->onMouseUp = [](Event* e) { Director::getInstance()->getGLView()->setCursorVisible(true); };
+    _lis->onMouseDown = [](Event* e) -> bool {
+        Director::getInstance()->getGLView()->setCursorVisible(false);
+        return true;
+    };
+
+    _lis->onMouseUp = [](Event* e) -> bool {
+        Director::getInstance()->getGLView()->setCursorVisible(true);
+        return true;
+    };
 
     _eventDispatcher->addEventListenerWithSceneGraphPriority(_lis, this);
 }
diff --git a/tests/cpp-tests/Source/InputTest/MouseTest.h b/tests/cpp-tests/Source/InputTest/MouseTest.h
index 5d46671535c2..a2a6e8bd8a62 100644
--- a/tests/cpp-tests/Source/InputTest/MouseTest.h
+++ b/tests/cpp-tests/Source/InputTest/MouseTest.h
@@ -42,10 +42,10 @@ class MouseEventTest : public BaseMouseTest
     MouseEventTest();
     ~MouseEventTest();
 
-    void onMouseDown(ax::Event* event);
-    void onMouseUp(ax::Event* event);
-    void onMouseMove(ax::Event* event);
-    void onMouseScroll(ax::Event* event);
+    bool onMouseDown(ax::Event* event);
+    bool onMouseUp(ax::Event* event);
+    bool onMouseMove(ax::Event* event);
+    bool onMouseScroll(ax::Event* event);
 
     virtual std::string title() const override;
     virtual std::string subtitle() const override;
diff --git a/tests/cpp-tests/Source/SpineTest/SpineTest.cpp b/tests/cpp-tests/Source/SpineTest/SpineTest.cpp
index e288945d817e..bef3a9c7cd2e 100644
--- a/tests/cpp-tests/Source/SpineTest/SpineTest.cpp
+++ b/tests/cpp-tests/Source/SpineTest/SpineTest.cpp
@@ -288,11 +288,13 @@ bool IKExample::init()
     // the current mouse location. The location is converted
     // to the skeleton's coordinate system.
     EventListenerMouse* mouseListener = EventListenerMouse::create();
-    mouseListener->onMouseMove        = [this](ax::Event* event) -> void {
+    mouseListener->onMouseMove        = [this](ax::Event* event) -> bool {
         // convert the mosue location to the skeleton's coordinate space
         // and store it.
         EventMouse* mouseEvent = dynamic_cast<EventMouse*>(event);
         position               = skeletonNode->convertToNodeSpace(mouseEvent->getLocationInView());
+
+        return true;
     };
     _eventDispatcher->addEventListenerWithSceneGraphPriority(mouseListener, this);