diff --git a/doc/changelog.dox b/doc/changelog.dox
index 7b6a293c5..c0b4c2508 100644
--- a/doc/changelog.dox
+++ b/doc/changelog.dox
@@ -1396,8 +1396,9 @@ See also:
     @relativeref{Platform::Sdl2Application,PointerEvent} and
     @relativeref{Platform::Sdl2Application,PointerMoveEvent} APIs that provide
     a better abstraction over general pointer input, not just a mouse alone.
-    The same change is done in @ref Platform::GlfwApplication.
--   @ref Platform::AbstractXApplication::MouseEvent::Button `WheelUp` and
+    The same change is done in @ref Platform::AbstractXApplication and
+    @ref Platform::GlfwApplication.
+-   @cpp Platform::AbstractXApplication::MouseEvent::Button::WheelUp @ce and
     `WheelDown` members are deprecated in favor of a dedicated
     @ref Platform::AbstractXApplication::mouseScrollEvent(). Similar change was
     done for all other application classes in 2016 already.
diff --git a/src/Magnum/Platform/AbstractXApplication.cpp b/src/Magnum/Platform/AbstractXApplication.cpp
index 43e7e5f94..1eed0d9bf 100644
--- a/src/Magnum/Platform/AbstractXApplication.cpp
+++ b/src/Magnum/Platform/AbstractXApplication.cpp
@@ -140,6 +140,34 @@ int AbstractXApplication::exec() {
     return _exitCode;
 }
 
+namespace {
+
+AbstractXApplication::Pointer buttonToPointer(const unsigned int button) {
+    switch(button) {
+        case 1 /*Button1*/:
+            return AbstractXApplication::Pointer::MouseLeft;
+        case 2 /*Button2*/:
+            return AbstractXApplication::Pointer::MouseMiddle;
+        case 3 /*Button3*/:
+            return AbstractXApplication::Pointer::MouseRight;
+    }
+
+    CORRADE_INTERNAL_ASSERT_UNREACHABLE();
+}
+
+AbstractXApplication::Pointers buttonsToPointers(const unsigned int state) {
+    AbstractXApplication::Pointers pointers;
+    if(state & Button1Mask)
+        pointers |= AbstractXApplication::Pointer::MouseLeft;
+    if(state & Button2Mask)
+        pointers |= AbstractXApplication::Pointer::MouseMiddle;
+    if(state & Button3Mask)
+        pointers |= AbstractXApplication::Pointer::MouseRight;
+    return pointers;
+}
+
+}
+
 bool AbstractXApplication::mainLoopIteration() {
     /* If exit was requested directly in the constructor, exit immediately
        without calling anything else */
@@ -184,15 +212,52 @@ bool AbstractXApplication::mainLoopIteration() {
                     if(event.type == ButtonPress)
                         mouseScrollEvent(e);
                 } else {
-                    MouseEvent e(MouseEvent::Button(event.xbutton.button), event.xkey.state, {event.xbutton.x, event.xbutton.y});
-                    event.type == ButtonPress ? mousePressEvent(e) : mouseReleaseEvent(e);
+                    const Pointer pointer = buttonToPointer(event.xbutton.button);
+                    Pointers pointers = buttonsToPointers(event.xbutton.state);
+                    /* Compared to other toolkits, the `pointers` don't include
+                       the currently pressed button on press yet, and still
+                       include the currently released button on release. Make
+                       it consistent. */
+                    if(event.type == ButtonPress) {
+                        CORRADE_INTERNAL_ASSERT(!(pointers & pointer));
+                        pointers |= pointer;
+                    } else {
+                        CORRADE_INTERNAL_ASSERT(pointers & pointer);
+                        pointers &= ~pointer;
+                    }
+
+                    /* If an additional mouse button was pressed or some other
+                       buttons are still left pressed after a release, call a
+                       move event instead */
+                    if((event.type == ButtonPress && (pointers & ~pointer)) ||
+                       (event.type == ButtonRelease && pointers)) {
+                        /* As we are patching up the set of currently pressed
+                           pointers, the move event can't just figure that
+                           out from the state */
+                        PointerMoveEvent e{pointer, pointers,
+                            {Float(event.xbutton.x), Float(event.xbutton.y)},
+                            event.xbutton.state};
+                        pointerMoveEvent(e);
+                    } else {
+                        PointerEvent e(pointer,
+                            {Float(event.xbutton.x), Float(event.xbutton.y)},
+                            event.xbutton.state);
+                        event.type == ButtonPress ?
+                            pointerPressEvent(e) : pointerReleaseEvent(e);
+                    }
                 }
             } break;
 
             /* Mouse move events */
             case MotionNotify: {
-                MouseMoveEvent e(event.xmotion.state, {event.xmotion.x, event.xmotion.y});
-                mouseMoveEvent(e);
+                /* Because for the move-from-press/release above we're patching
+                   up the set of pressed pointers, we need to explicitly pass
+                   it in here as well. No need to patch anything in this case
+                   tho -- the set should be up-to-date. */
+                PointerMoveEvent e({}, buttonsToPointers(event.xmotion.state),
+                    {Float(event.xmotion.x), Float(event.xmotion.y)},
+                    event.xmotion.state);
+                pointerMoveEvent(e);
             } break;
         }
     }
@@ -208,9 +273,92 @@ bool AbstractXApplication::mainLoopIteration() {
 void AbstractXApplication::viewportEvent(ViewportEvent&) {}
 void AbstractXApplication::keyPressEvent(KeyEvent&) {}
 void AbstractXApplication::keyReleaseEvent(KeyEvent&) {}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+namespace {
+
+CORRADE_IGNORE_DEPRECATED_PUSH
+AbstractXApplication::MouseEvent::Button pointerToButton(const AbstractXApplication::Pointer pointer) {
+    switch(pointer) {
+        case AbstractXApplication::Pointer::MouseLeft:
+            return AbstractXApplication::MouseEvent::Button::Left;
+        case AbstractXApplication::Pointer::MouseMiddle:
+            return AbstractXApplication::MouseEvent::Button::Middle;
+        case AbstractXApplication::Pointer::MouseRight:
+            return AbstractXApplication::MouseEvent::Button::Right;
+    }
+
+    CORRADE_INTERNAL_ASSERT_UNREACHABLE();
+}
+CORRADE_IGNORE_DEPRECATED_POP
+
+}
+#endif
+
+void AbstractXApplication::pointerPressEvent(PointerEvent& event) {
+    #ifdef MAGNUM_BUILD_DEPRECATED
+    CORRADE_IGNORE_DEPRECATED_PUSH
+    /* The positions are reported in integers in the first place, no need to
+       round anything */
+    MouseEvent mouseEvent{pointerToButton(event.pointer()), event._modifiers, Vector2i{event.position()}};
+    mousePressEvent(mouseEvent);
+    CORRADE_IGNORE_DEPRECATED_POP
+    #else
+    static_cast<void>(event);
+    #endif
+}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+CORRADE_IGNORE_DEPRECATED_PUSH
 void AbstractXApplication::mousePressEvent(MouseEvent&) {}
+CORRADE_IGNORE_DEPRECATED_POP
+#endif
+
+void AbstractXApplication::pointerReleaseEvent(PointerEvent& event) {
+    #ifdef MAGNUM_BUILD_DEPRECATED
+    CORRADE_IGNORE_DEPRECATED_PUSH
+    /* The positions are reported in integers in the first place, no need to
+       round anything */
+    MouseEvent mouseEvent{pointerToButton(event.pointer()), event._modifiers, Vector2i{event.position()}};
+    mouseReleaseEvent(mouseEvent);
+    CORRADE_IGNORE_DEPRECATED_POP
+    #else
+    static_cast<void>(event);
+    #endif
+}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+CORRADE_IGNORE_DEPRECATED_PUSH
 void AbstractXApplication::mouseReleaseEvent(MouseEvent&) {}
+CORRADE_IGNORE_DEPRECATED_POP
+#endif
+
+void AbstractXApplication::pointerMoveEvent(PointerMoveEvent& event) {
+    #ifdef MAGNUM_BUILD_DEPRECATED
+    CORRADE_IGNORE_DEPRECATED_PUSH
+    /* If the event is due to some button being additionally pressed or one
+       button from a larger set being released, delegate to a press/release
+       event instead */
+    if(event.pointer()) {
+        MouseEvent mouseEvent{pointerToButton(*event.pointer()), event._modifiers,
+            Vector2i{event.position()}};
+        event.pointers() >= *event.pointer() ?
+            mousePressEvent(mouseEvent) : mouseReleaseEvent(mouseEvent);
+    } else {
+        MouseMoveEvent mouseEvent{event._modifiers, Vector2i{event.position()}};
+        mouseMoveEvent(mouseEvent);
+    }
+    CORRADE_IGNORE_DEPRECATED_POP
+    #else
+    static_cast<void>(event);
+    #endif
+}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+CORRADE_IGNORE_DEPRECATED_PUSH
 void AbstractXApplication::mouseMoveEvent(MouseMoveEvent&) {}
+CORRADE_IGNORE_DEPRECATED_POP
+#endif
 
 void AbstractXApplication::mouseScrollEvent(MouseScrollEvent& event) {
     #ifdef MAGNUM_BUILD_DEPRECATED
@@ -232,4 +380,12 @@ AbstractXApplication::Configuration::Configuration():
     _size(800, 600) {}
 AbstractXApplication::Configuration::~Configuration() = default;
 
+AbstractXApplication::Pointers AbstractXApplication::KeyEvent::pointers() const {
+    return buttonsToPointers(_modifiers);
+}
+
+AbstractXApplication::Pointers AbstractXApplication::MouseScrollEvent::pointers() const {
+    return buttonsToPointers(_modifiers);
+}
+
 }}
diff --git a/src/Magnum/Platform/AbstractXApplication.h b/src/Magnum/Platform/AbstractXApplication.h
index c9474efe7..072faffa5 100644
--- a/src/Magnum/Platform/AbstractXApplication.h
+++ b/src/Magnum/Platform/AbstractXApplication.h
@@ -104,10 +104,28 @@ class AbstractXApplication {
         class ViewportEvent;
         class InputEvent;
         class KeyEvent;
+        class PointerEvent;
+        class PointerMoveEvent;
+        #ifdef MAGNUM_BUILD_DEPRECATED
         class MouseEvent;
         class MouseMoveEvent;
+        #endif
         class MouseScrollEvent;
 
+        /* The damn thing cannot handle forward enum declarations */
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        enum class Pointer: UnsignedByte;
+        #endif
+
+        /**
+         * @brief Set of pointer types
+         * @m_since_latest
+         *
+         * @see @ref KeyEvent::pointers(), @ref PointerMoveEvent::pointers(),
+         *      @ref MouseScrollEvent::pointers()
+         */
+        typedef Containers::EnumSet<Pointer> Pointers;
+
         /** @brief Copying is not allowed */
         AbstractXApplication(const AbstractXApplication&) = delete;
 
@@ -286,16 +304,92 @@ class AbstractXApplication {
          * @}
          */
 
-        /** @{ @name Mouse handling */
+        /** @{ @name Pointer handling */
+
+        /**
+         * @brief Pointer press event
+         * @m_since_latest
+         *
+         * Called when a mouse is pressed. Note that if at least one mouse
+         * button is already pressed and another button gets pressed in
+         * addition, @ref pointerMoveEvent() with the new combination is
+         * called, not this function.
+         *
+         * On builds with @ref MAGNUM_BUILD_DEPRECATED enabled, default
+         * implementation delegates to @ref mousePressEvent(). On builds with
+         * deprecated functionality disabled, default implementation does
+         * nothing.
+         */
+        virtual void pointerPressEvent(PointerEvent& event);
+
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @brief Mouse press event
+         * @m_deprecated_since_latest Use @ref pointerPressEvent() instead,
+         *      which is a better abstraction for covering both mouse and touch
+         *      / pen input.
+         *
+         * Default implementation does nothing.
+         */
+        virtual CORRADE_DEPRECATED("use pointerPressEvent() instead") void mousePressEvent(MouseEvent& event);
+        #endif
 
-        /** @copydoc Sdl2Application::mousePressEvent() */
-        virtual void mousePressEvent(MouseEvent& event);
+        /**
+         * @brief Pointer release event
+         * @m_since_latest
+         *
+         * Called when a mouse is released. Note that if multiple mouse buttons
+         * are pressed and one of these is released, @ref pointerMoveEvent()
+         * with the new combination is called, not this function.
+         *
+         * On builds with @ref MAGNUM_BUILD_DEPRECATED enabled, default
+         * implementation delegates to @ref mouseReleaseEvent(). On builds with
+         * deprecated functionality disabled, default implementation does
+         * nothing.
+         */
+        virtual void pointerReleaseEvent(PointerEvent& event);
+
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @brief Mouse release event
+         * @m_deprecated_since_latest Use @ref pointerReleaseEvent() instead,
+         *      which is a better abstraction for covering both mouse and touch
+         *      / pen input.
+         *
+         * Default implementation does nothing.
+         */
+        virtual CORRADE_DEPRECATED("use pointerReleaseEvent() instead") void mouseReleaseEvent(MouseEvent& event);
+        #endif
 
-        /** @copydoc Sdl2Application::mouseReleaseEvent() */
-        virtual void mouseReleaseEvent(MouseEvent& event);
+        /**
+         * @brief Pointer move event
+         * @m_since_latest
+         *
+         * Called when any of the currently pressed pointers is moved or
+         * changes its properties. Gets called also if the set of pressed mouse
+         * buttons changes.
+         *
+         * On builds with @ref MAGNUM_BUILD_DEPRECATED enabled, default
+         * implementation delegates to @ref mouseMoveEvent(), or if
+         * @ref PointerMoveEvent::pointer() is not
+         * @relativeref{Corrade,Containers::NullOpt}, to either
+         * @ref mousePressEvent() or @ref mouseReleaseEvent(). On builds with
+         * deprecated functionality disabled, default implementation does
+         * nothing.
+         */
+        virtual void pointerMoveEvent(PointerMoveEvent& event);
 
-        /** @copydoc Sdl2Application::mouseMoveEvent() */
-        virtual void mouseMoveEvent(MouseMoveEvent& event);
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @brief Mouse move event
+         * @m_deprecated_since_latest Use @ref pointerMoveEvent() instead,
+         *      which is a better abstraction for covering both mouse and touch
+         *      / pen input.
+         *
+         * Default implementation does nothing.
+         */
+        virtual CORRADE_DEPRECATED("use pointerMoveEvent() instead") void mouseMoveEvent(MouseMoveEvent& event);
+        #endif
 
         /**
          * @brief Mouse scroll event
@@ -351,6 +445,31 @@ class AbstractXApplication {
         Flags _flags;
 };
 
+/**
+@brief Pointer type
+@m_since_latest
+
+@see @ref Pointers, @ref KeyEvent::pointers(), @ref PointerEvent::pointer(),
+    @ref PointerMoveEvent::pointer(), @ref PointerMoveEvent::pointers(),
+    @ref MouseScrollEvent::pointers()
+*/
+enum class AbstractXApplication::Pointer: UnsignedByte {
+    /** Left mouse button. Corresponds to `Button1` / `Button1Mask`. */
+    MouseLeft = 1 << 0,
+
+    /**
+     * Middle mouse button. Corresponds to `Button2` / `Button2Mask`.
+     */
+    MouseMiddle = 1 << 1,
+
+    /**
+     * Right mouse button. Corresponds to `Button3` / `Button3Mask`.
+     */
+    MouseRight = 1 << 2
+};
+
+CORRADE_ENUMSET_OPERATORS(AbstractXApplication::Pointers)
+
 /**
 @brief OpenGL context configuration
 
@@ -563,9 +682,10 @@ class AbstractXApplication::ViewportEvent {
 /**
 @brief Base for input events
 
-@see @ref KeyEvent, @ref MouseEvent, @ref MouseMoveEvent, @ref keyPressEvent(),
-    @ref keyReleaseEvent(), @ref mousePressEvent(), @ref mouseReleaseEvent(),
-    @ref mouseMoveEvent()
+@see @ref KeyEvent, @ref PointerEvent, @ref PointerMoveEvent,
+    @ref MouseScrollEvent, @ref keyPressEvent(), @ref keyReleaseEvent(),
+    @ref pointerPressEvent(), @ref pointerReleaseEvent(),
+    @ref pointerMoveEvent(), @ref mouseScrollEvent()
 */
 class AbstractXApplication::InputEvent {
     public:
@@ -621,12 +741,12 @@ class AbstractXApplication::InputEvent {
          */
         typedef Containers::EnumSet<Modifier> Modifiers;
 
+        #ifdef MAGNUM_BUILD_DEPRECATED
         /**
          * @brief Mouse button
-         *
-         * @see @ref Buttons, @ref buttons()
+         * @m_deprecated_since_latest Use @ref Pointer instead.
          */
-        enum class Button: unsigned int {
+        enum class CORRADE_DEPRECATED_ENUM("use Pointer instead") Button: unsigned int {
             Left = Button1Mask,     /**< Left button */
             Middle = Button2Mask,   /**< Middle button */
             Right = Button3Mask     /**< Right button */
@@ -634,10 +754,12 @@ class AbstractXApplication::InputEvent {
 
         /**
          * @brief Set of mouse buttons
-         *
-         * @see @ref buttons()
+         * @m_deprecated_since_latest Use @ref Pointers instead.
          */
-        typedef Containers::EnumSet<Button> Buttons;
+        CORRADE_IGNORE_DEPRECATED_PUSH
+        typedef CORRADE_DEPRECATED("use Pointers instead") Containers::EnumSet<Button> Buttons;
+        CORRADE_IGNORE_DEPRECATED_POP
+        #endif
 
         /** @brief Copying is not allowed */
         InputEvent(const InputEvent&) = delete;
@@ -662,10 +784,16 @@ class AbstractXApplication::InputEvent {
             return Modifiers(_modifiers & (ShiftMask|ControlMask|Mod1Mask|Mod5Mask|LockMask|Mod2Mask));
         }
 
-        /** @brief Mouse buttons */
-        Buttons buttons() const {
+        #ifdef MAGNUM_BUILD_DEPRECATED
+        /**
+         * @brief Mouse buttons
+         * @m_deprecated_since_latest Use @ref KeyEvent::pointers() or
+         *      @ref PointerMoveEvent::pointers() instead.
+         */
+        CORRADE_DEPRECATED("use pointers() instead") Buttons buttons() const {
             return Buttons(_modifiers & (Button1Mask|Button2Mask|Button3Mask));
         }
+        #endif
 
     #ifndef DOXYGEN_GENERATING_OUTPUT
     protected:
@@ -675,16 +803,19 @@ class AbstractXApplication::InputEvent {
     #endif
 
     private:
-        #ifdef MAGNUM_BUILD_DEPRECATED
-        friend AbstractXApplication; /* mouseScrollEvent() backwards compat */
-        #endif
+        friend AbstractXApplication;
 
         unsigned int _modifiers;
         bool _accepted;
 };
 
 CORRADE_ENUMSET_OPERATORS(AbstractXApplication::InputEvent::Modifiers)
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+CORRADE_IGNORE_DEPRECATED_PUSH
 CORRADE_ENUMSET_OPERATORS(AbstractXApplication::InputEvent::Buttons)
+CORRADE_IGNORE_DEPRECATED_POP
+#endif
 
 /**
 @brief Key event
@@ -1034,6 +1165,15 @@ class AbstractXApplication::KeyEvent: public AbstractXApplication::InputEvent {
         /** @brief Position */
         Vector2i position() const { return _position; }
 
+        /**
+         * @brief Pointer types pressed in this event
+         * @m_since_latest
+         *
+         * Returns an empty set if no pointers are pressed in addition to the
+         * key.
+         */
+        Pointers pointers() const;
+
     private:
         friend AbstractXApplication;
 
@@ -1043,13 +1183,57 @@ class AbstractXApplication::KeyEvent: public AbstractXApplication::InputEvent {
         const Vector2i _position;
 };
 
+/**
+@brief Pointer event
+@m_since_latest
+
+@see @ref PointerMoveEvent, @ref pointerPressEvent(),
+    @ref pointerReleaseEvent()
+*/
+class AbstractXApplication::PointerEvent: public InputEvent {
+    public:
+        /** @brief Copying is not allowed */
+        PointerEvent(const PointerEvent&) = delete;
+
+        /** @brief Moving is not allowed */
+        PointerEvent(PointerEvent&&) = delete;
+
+        /** @brief Copying is not allowed */
+        PointerEvent& operator=(const PointerEvent&) = delete;
+
+        /** @brief Moving is not allowed */
+        PointerEvent& operator=(PointerEvent&&) = delete;
+
+        /** @brief Pointer type that was pressed or released */
+        Pointer pointer() const { return _pointer; }
+
+        /**
+         * @brief Position
+         *
+         * For mouse input the position is always reported in whole pixels.
+         */
+        Vector2 position() const { return _position; }
+
+    private:
+        friend AbstractXApplication;
+
+        explicit PointerEvent(Pointer pointer, const Vector2& position, unsigned int modifiers): InputEvent{modifiers}, _pointer(pointer), _position{position} {}
+
+        const Pointer _pointer;
+        const Vector2 _position;
+};
+
+#ifdef MAGNUM_BUILD_DEPRECATED
 /**
 @brief Mouse event
+@m_deprecated_since_latest Use @ref PointerEvent, @ref pointerPressEvent() and
+    @ref pointerReleaseEvent() instead, which is a better abstraction for
+    covering both mouse and touch / pen input.
 
 @see @ref MouseMoveEvent, @ref MouseScrollEvent, @ref mousePressEvent(),
     @ref mouseReleaseEvent()
 */
-class AbstractXApplication::MouseEvent: public AbstractXApplication::InputEvent {
+class CORRADE_DEPRECATED("use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead") AbstractXApplication::MouseEvent: public AbstractXApplication::InputEvent {
     public:
         /**
          * @brief Mouse button
@@ -1092,13 +1276,75 @@ class AbstractXApplication::MouseEvent: public AbstractXApplication::InputEvent
         const Button _button;
         const Vector2i _position;
 };
+#endif
+
+/**
+@brief Pointer move event
+@m_since_latest
+
+@see @ref PointerEvent, @ref pointerMoveEvent()
+*/
+class AbstractXApplication::PointerMoveEvent: public InputEvent {
+    public:
+        /** @brief Copying is not allowed */
+        PointerMoveEvent(const PointerMoveEvent&) = delete;
+
+        /** @brief Moving is not allowed */
+        PointerMoveEvent(PointerMoveEvent&&) = delete;
+
+        /** @brief Copying is not allowed */
+        PointerMoveEvent& operator=(const PointerMoveEvent&) = delete;
+
+        /** @brief Moving is not allowed */
+        PointerMoveEvent& operator=(PointerMoveEvent&&) = delete;
+
+        /**
+         * @brief Pointer type that was added or removed from the set of pressed pointers
+         *
+         * Is non-empty only in case a mouse button was pressed in addition to
+         * an already pressed button, or if one mouse button from multiple
+         * pressed buttons was released. If non-empty and @ref pointers() don't
+         * contain given @ref Pointer value, the button was released, if they
+         * contain given value, the button was pressed.
+         */
+        Containers::Optional<Pointer> pointer() const { return _pointer; }
+
+        /**
+         * @brief Pointer types pressed in this event
+         *
+         * Returns an empty set if no pointers are pressed, which happens for
+         * example when a mouse is just moved around.
+         * @see @ref pointer()
+         */
+        Pointers pointers() const { return _pointers; }
+
+        /**
+         * @brief Position
+         *
+         * For mouse input the position is always reported in whole pixels.
+         */
+        Vector2 position() const { return _position; }
+
+    private:
+        friend AbstractXApplication;
+
+        explicit PointerMoveEvent(Containers::Optional<Pointer> pointer, Pointers pointers, const Vector2& position, unsigned int modifiers): InputEvent{modifiers}, _pointer{pointer}, _pointers{pointers}, _position{position} {}
+
+        const Containers::Optional<Pointer> _pointer;
+        Pointers _pointers;
+        const Vector2 _position;
+};
 
+#ifdef MAGNUM_BUILD_DEPRECATED
 /**
 @brief Mouse move event
+@m_deprecated_since_latest Use @ref PointerMoveEvent and
+    @ref pointerMoveEvent() instead, which is a better abstraction for covering
+    both mouse and touch / pen input.
 
 @see @ref MouseEvent, @ref MouseScrollEvent, @ref mouseMoveEvent()
 */
-class AbstractXApplication::MouseMoveEvent: public AbstractXApplication::InputEvent {
+class CORRADE_DEPRECATED("use PointerMoveEvent and pointerMoveEvent() instead") AbstractXApplication::MouseMoveEvent: public AbstractXApplication::InputEvent {
     public:
         /** @brief Position */
         Vector2i position() const { return _position; }
@@ -1110,12 +1356,13 @@ class AbstractXApplication::MouseMoveEvent: public AbstractXApplication::InputEv
 
         const Vector2i _position;
 };
+#endif
 
 /**
 @brief Mouse scroll event
 @m_since_latest
 
-@see @ref MouseEvent, @ref MouseMoveEvent, @ref mouseScrollEvent()
+@see @ref PointerEvent, @ref PointerMoveEvent, @ref mouseScrollEvent()
 */
 class AbstractXApplication::MouseScrollEvent: public InputEvent {
     public:
@@ -1129,6 +1376,14 @@ class AbstractXApplication::MouseScrollEvent: public InputEvent {
         /** @brief Position */
         Vector2i position() const { return _position; }
 
+        /**
+         * @brief Pointer types pressed in this event
+         *
+         * Returns an empty set if no pointers are pressed in addition to the
+         * mouse wheel.
+         */
+        Pointers pointers() const;
+
     private:
         friend AbstractXApplication;
 
diff --git a/src/Magnum/Platform/Test/AbstractXApplicationTest.cpp b/src/Magnum/Platform/Test/AbstractXApplicationTest.cpp
index 6ae6fc07f..00eefcd3f 100644
--- a/src/Magnum/Platform/Test/AbstractXApplicationTest.cpp
+++ b/src/Magnum/Platform/Test/AbstractXApplicationTest.cpp
@@ -57,7 +57,23 @@ static Debug& operator<<(Debug& debug, Application::InputEvent::Modifier value)
     return debug << "(" << Debug::nospace << UnsignedInt(value) << Debug::nospace << ")";
 }
 
-static Debug& operator<<(Debug& debug, Application::MouseMoveEvent::Button value) {
+static Debug& operator<<(Debug& debug, Application::Pointer value) {
+    debug << "Pointer" << Debug::nospace;
+
+    switch(value) {
+        #define _c(value) case Application::Pointer::value: return debug << "::" #value;
+        _c(MouseLeft)
+        _c(MouseMiddle)
+        _c(MouseRight)
+        #undef _c
+    }
+
+    return debug << "(" << Debug::nospace << UnsignedInt(value) << Debug::nospace << ")";
+}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+CORRADE_IGNORE_DEPRECATED_PUSH
+CORRADE_UNUSED static Debug& operator<<(Debug& debug, Application::MouseMoveEvent::Button value) {
     debug << "Button" << Debug::nospace;
 
     switch(value) {
@@ -70,6 +86,8 @@ static Debug& operator<<(Debug& debug, Application::MouseMoveEvent::Button value
 
     return debug << "(" << Debug::nospace << UnsignedInt(value) << Debug::nospace << ")";
 }
+CORRADE_IGNORE_DEPRECATED_POP
+#endif
 
 namespace Test { namespace {
 
@@ -84,7 +102,18 @@ Debug& operator<<(Debug& debug, Application::InputEvent::Modifiers value) {
     });
 }
 
-Debug& operator<<(Debug& debug, Application::MouseEvent::Button value) {
+
+Debug& operator<<(Debug& debug, Application::Pointers value) {
+    return Containers::enumSetDebugOutput(debug, value, "Pointers{}", {
+        Application::Pointer::MouseLeft,
+        Application::Pointer::MouseMiddle,
+        Application::Pointer::MouseRight,
+    });
+}
+
+#ifdef MAGNUM_BUILD_DEPRECATED
+CORRADE_IGNORE_DEPRECATED_PUSH
+CORRADE_UNUSED Debug& operator<<(Debug& debug, Application::MouseEvent::Button value) {
     debug << "Button" << Debug::nospace;
 
     switch(value) {
@@ -100,13 +129,15 @@ Debug& operator<<(Debug& debug, Application::MouseEvent::Button value) {
     return debug << "(" << Debug::nospace << UnsignedInt(value) << Debug::nospace << ")";
 }
 
-Debug& operator<<(Debug& debug, Application::MouseMoveEvent::Buttons value) {
+CORRADE_UNUSED Debug& operator<<(Debug& debug, Application::MouseMoveEvent::Buttons value) {
     return Containers::enumSetDebugOutput(debug, value, "Buttons{}", {
         Application::MouseMoveEvent::Button::Left,
         Application::MouseMoveEvent::Button::Middle,
         Application::MouseMoveEvent::Button::Right,
     });
 }
+CORRADE_IGNORE_DEPRECATED_POP
+#endif
 
 Debug& operator<<(Debug& debug, const Application::KeyEvent::Key value) {
     debug << "Key" << Debug::nospace;
@@ -241,31 +272,44 @@ struct AbstractXApplicationTest: Platform::Application {
         swapBuffers();
     }
 
+    /* Set to 0 to test the deprecated mouse events instead */
+    #if 1
+    void pointerPressEvent(PointerEvent& event) override {
+        Debug{} << "pointer press:" << event.pointer() << event.modifiers() << Debug::packed << event.position();
+    }
+    void pointerReleaseEvent(PointerEvent& event) override {
+        Debug{} << "pointer release:" << event.pointer() << event.modifiers() << Debug::packed << event.position();
+    }
+    void pointerMoveEvent(PointerMoveEvent& event) override {
+        Debug{} << "pointer move:" << event.pointer() << event.pointers() << event.modifiers() << Debug::packed << event.position();
+    }
+    #else
+    CORRADE_IGNORE_DEPRECATED_PUSH
     void mousePressEvent(MouseEvent& event) override {
         Debug{} << "mouse press:" << event.button() << event.buttons() << event.modifiers() << Debug::packed << event.position();
     }
-
     void mouseReleaseEvent(MouseEvent& event) override {
         Debug{} << "mouse release:" << event.button() << event.buttons() << event.modifiers() << Debug::packed << event.position();
     }
-
     void mouseMoveEvent(MouseMoveEvent& event) override {
         Debug{} << "mouse move:" << event.buttons() << event.modifiers() << Debug::packed << event.position();
     }
+    CORRADE_IGNORE_DEPRECATED_POP
+    #endif
 
     /* Comment out to test the deprecated scroll as press/release reporting */
     #if 1
     void mouseScrollEvent(MouseScrollEvent& event) override {
-        Debug{} << "mouse scroll:" << event.buttons() << event.modifiers() << Debug::packed << event.offset() << Debug::packed << event.position();
+        Debug{} << "mouse scroll:" << event.pointers() << event.modifiers() << Debug::packed << event.offset() << Debug::packed << event.position();
     }
     #endif
 
     void keyPressEvent(KeyEvent& event) override {
-        Debug{} << "key press:" << event.key() << int(event.key()) << event.modifiers() << event.buttons() << Debug::packed << event.position();
+        Debug{} << "key press:" << event.key() << int(event.key()) << event.modifiers() << event.pointers() << Debug::packed << event.position();
     }
 
     void keyReleaseEvent(KeyEvent& event) override {
-        Debug{} << "key release:" << event.key() << int(event.key()) << event.modifiers() << event.buttons() << Debug::packed << event.position();
+        Debug{} << "key release:" << event.key() << int(event.key()) << event.modifiers() << event.pointers() << Debug::packed << event.position();
     }
 };