Changeset 285986 in webkit


Ignore:
Timestamp:
Nov 17, 2021 11:58:23 PM (8 months ago)
Author:
graouts@webkit.org
Message:

[Model] [macOS] Add support for interaction on macOS
​https://bugs.webkit.org/show_bug.cgi?id=233105
<rdar://problem/80079386>

Reviewed by Wenson Hsieh.

Source/WebCore:

Capture mouse events after the mouse button is pressed over a <model> element,
unless preventDefault() is called, and forward those events through ModelPlayer
to the UI process.

  • Modules/model-element/HTMLModelElement.cpp:

(WebCore::HTMLModelElement::defaultEventHandler):
(WebCore::HTMLModelElement::dragDidStart):
(WebCore::HTMLModelElement::dragDidChange):
(WebCore::HTMLModelElement::dragDidEnd):

  • Modules/model-element/HTMLModelElement.h:
  • Modules/model-element/ModelPlayer.cpp:

(WebCore::ModelPlayer::supportsMouseInteraction):

  • Modules/model-element/ModelPlayer.h:
  • Modules/model-element/dummy/DummyModelPlayer.cpp:

(WebCore::DummyModelPlayer::handleMouseDown):
(WebCore::DummyModelPlayer::handleMouseMove):
(WebCore::DummyModelPlayer::handleMouseUp):

  • Modules/model-element/dummy/DummyModelPlayer.h:
  • Modules/model-element/scenekit/SceneKitModelPlayer.h:
  • Modules/model-element/scenekit/SceneKitModelPlayer.mm:

(WebCore::SceneKitModelPlayer::handleMouseDown):
(WebCore::SceneKitModelPlayer::handleMouseMove):
(WebCore::SceneKitModelPlayer::handleMouseUp):

Source/WebCore/PAL:

Add new ARQL SPIs.

  • pal/spi/mac/SystemPreviewSPI.h:

Source/WebKit:

Forward mouse events captured in the Web process to the matching ASVInlinePreview.

  • UIProcess/Cocoa/ModelElementControllerCocoa.mm:

(WebKit::ModelElementController::previewForUUID):
(WebKit::ModelElementController::handleMouseDownForModelElement):
(WebKit::ModelElementController::handleMouseMoveForModelElement):
(WebKit::ModelElementController::handleMouseUpForModelElement):

  • UIProcess/ModelElementController.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::handleMouseDownForModelElement):
(WebKit::WebPageProxy::handleMouseMoveForModelElement):
(WebKit::WebPageProxy::handleMouseUpForModelElement):

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebPageProxy.messages.in:
  • WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.h:
  • WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.mm:

(WebKit::ARKitInlinePreviewModelPlayerIOS::handleMouseDown):
(WebKit::ARKitInlinePreviewModelPlayerIOS::handleMouseMove):
(WebKit::ARKitInlinePreviewModelPlayerIOS::handleMouseUp):

  • WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.h:
  • WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm:

(WebKit::ARKitInlinePreviewModelPlayerMac::supportsMouseInteraction):
(WebKit::ARKitInlinePreviewModelPlayerMac::handleMouseDown):
(WebKit::ARKitInlinePreviewModelPlayerMac::handleMouseMove):
(WebKit::ARKitInlinePreviewModelPlayerMac::handleMouseUp):

Location:
trunk/Source
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r285985 r285986  
     12021-11-18 Antoine Quint  <graouts@webkit.org>
     2
     3        [Model] [macOS] Add support for interaction on macOS
     4        https://bugs.webkit.org/show_bug.cgi?id=233105
     5        <rdar://problem/80079386>
     6
     7        Reviewed by Wenson Hsieh.
     8
     9        Capture mouse events after the mouse button is pressed over a <model> element,
     10        unless preventDefault() is called, and forward those events through ModelPlayer
     11        to the UI process.
     12
     13        * Modules/model-element/HTMLModelElement.cpp:
     14        (WebCore::HTMLModelElement::defaultEventHandler):
     15        (WebCore::HTMLModelElement::dragDidStart):
     16        (WebCore::HTMLModelElement::dragDidChange):
     17        (WebCore::HTMLModelElement::dragDidEnd):
     18        * Modules/model-element/HTMLModelElement.h:
     19        * Modules/model-element/ModelPlayer.cpp:
     20        (WebCore::ModelPlayer::supportsMouseInteraction):
     21        * Modules/model-element/ModelPlayer.h:
     22        * Modules/model-element/dummy/DummyModelPlayer.cpp:
     23        (WebCore::DummyModelPlayer::handleMouseDown):
     24        (WebCore::DummyModelPlayer::handleMouseMove):
     25        (WebCore::DummyModelPlayer::handleMouseUp):
     26        * Modules/model-element/dummy/DummyModelPlayer.h:
     27        * Modules/model-element/scenekit/SceneKitModelPlayer.h:
     28        * Modules/model-element/scenekit/SceneKitModelPlayer.mm:
     29        (WebCore::SceneKitModelPlayer::handleMouseDown):
     30        (WebCore::SceneKitModelPlayer::handleMouseMove):
     31        (WebCore::SceneKitModelPlayer::handleMouseUp):
     32
    1332021-11-17  Youenn Fablet  <youenn@apple.com>
    234

  • trunk/Source/WebCore/Modules/model-element/HTMLModelElement.cpp

    r285922 r285986  
    3434#include "ElementChildIterator.h"
    3535#include "ElementInlines.h"
     36#include "EventHandler.h"
     37#include "EventNames.h"
    3638#include "GraphicsLayer.h"
    3739#include "GraphicsLayerCA.h"
    … …  
    4446#include "ModelPlayer.h"
    4547#include "ModelPlayerProvider.h"
     48#include "MouseEvent.h"
    4649#include "Page.h"
     50#include "PlatformMouseEvent.h"
    4751#include "RenderLayer.h"
    4852#include "RenderLayerBacking.h"
    … …  
    290294}
    291295
     296// MARK: - Interaction support.
     297
     298void HTMLModelElement::defaultEventHandler(Event& event)
     299{
     300    if (!m_modelPlayer || !m_modelPlayer->supportsMouseInteraction())
     301        return;
     302
     303    auto type = event.type();
     304    if (type != eventNames().mousedownEvent && type != eventNames().mousemoveEvent && type != eventNames().mouseupEvent)
     305        return;
     306
     307    ASSERT(is<MouseEvent>(event));
     308    auto& mouseEvent = downcast<MouseEvent>(event);
     309
     310    if (mouseEvent.button() != LeftButton)
     311        return;
     312
     313    if (type == eventNames().mousedownEvent && !m_isDragging && !event.defaultPrevented())
     314        dragDidStart(mouseEvent);
     315    else if (type == eventNames().mousemoveEvent && m_isDragging)
     316        dragDidChange(mouseEvent);
     317    else if (type == eventNames().mouseupEvent && m_isDragging)
     318        dragDidEnd(mouseEvent);
     319}
     320
     321void HTMLModelElement::dragDidStart(MouseEvent& event)
     322{
     323    ASSERT(!m_isDragging);
     324
     325    RefPtr frame = document().frame();
     326    if (!frame)
     327        return;
     328
     329    frame->eventHandler().setCapturingMouseEventsElement(this);
     330    event.setDefaultHandled();
     331    m_isDragging = true;
     332
     333    if (m_modelPlayer)
     334        m_modelPlayer->handleMouseDown(event.pageLocation(), event.timeStamp());
     335}
     336
     337void HTMLModelElement::dragDidChange(MouseEvent& event)
     338{
     339    ASSERT(m_isDragging);
     340
     341    event.setDefaultHandled();
     342
     343    if (m_modelPlayer)
     344        m_modelPlayer->handleMouseMove(event.pageLocation(), event.timeStamp());
     345}
     346
     347void HTMLModelElement::dragDidEnd(MouseEvent& event)
     348{
     349    ASSERT(m_isDragging);
     350
     351    RefPtr frame = document().frame();
     352    if (!frame)
     353        return;
     354
     355    frame->eventHandler().setCapturingMouseEventsElement(nullptr);
     356    event.setDefaultHandled();
     357    m_isDragging = false;
     358
     359    if (m_modelPlayer)
     360        m_modelPlayer->handleMouseUp(event.pageLocation(), event.timeStamp());
     361}
     362
    292363}
    293364

  • trunk/Source/WebCore/Modules/model-element/HTMLModelElement.h

    r285922 r285986  
    4141namespace WebCore {
    4242
     43class Event;
    4344class Model;
    4445class ModelPlayer;
     46class MouseEvent;
    4547
    4648template<typename IDLType> class DOMPromiseProxyWithResolveCallback;
    … …  
    9395    GraphicsLayer::PlatformLayerID platformLayerID() final;
    9496
     97    void defaultEventHandler(Event&) final;
     98    void dragDidStart(MouseEvent&);
     99    void dragDidChange(MouseEvent&);
     100    void dragDidEnd(MouseEvent&);
     101
    95102    URL m_sourceURL;
    96103    CachedResourceHandle<CachedRawResource> m_resource;
    … …  
    99106    UniqueRef<ReadyPromise> m_readyPromise;
    100107    bool m_dataComplete { false };
     108    bool m_isDragging { false };
    101109
    102110    RefPtr<ModelPlayer> m_modelPlayer;

  • trunk/Source/WebCore/Modules/model-element/ModelPlayer.cpp

    r285637 r285986  
    3131ModelPlayer::~ModelPlayer() = default;
    3232
     33bool ModelPlayer::supportsMouseInteraction()
     34{
     35    return false;
    3336}
     37
     38}

  • trunk/Source/WebCore/Modules/model-element/ModelPlayer.h

    r285922 r285986  
    2626#pragma once
    2727
     28#include "LayoutPoint.h"
    2829#include "LayoutSize.h"
    2930#include "PlatformLayer.h"
    3031#include <wtf/Forward.h>
     32#include <wtf/MonotonicTime.h>
    3133
    3234namespace WebCore {
    … …  
    4244    virtual PlatformLayer* layer() = 0;
    4345    virtual void enterFullscreen() = 0;
     46    virtual bool supportsMouseInteraction();
     47    virtual void handleMouseDown(const LayoutPoint&, MonotonicTime) = 0;
     48    virtual void handleMouseMove(const LayoutPoint&, MonotonicTime) = 0;
     49    virtual void handleMouseUp(const LayoutPoint&, MonotonicTime) = 0;
     50
    4451};
    4552

  • trunk/Source/WebCore/Modules/model-element/dummy/DummyModelPlayer.cpp

    r285922 r285986  
    5959}
    6060
     61void DummyModelPlayer::handleMouseDown(const LayoutPoint&, MonotonicTime)
     62{
    6163}
     64
     65void DummyModelPlayer::handleMouseMove(const LayoutPoint&, MonotonicTime)
     66{
     67}
     68
     69void DummyModelPlayer::handleMouseUp(const LayoutPoint&, MonotonicTime)
     70{
     71}
     72
     73}

  • trunk/Source/WebCore/Modules/model-element/dummy/DummyModelPlayer.h

    r285922 r285986  
    4545    PlatformLayer* layer() override;
    4646    void enterFullscreen() override;
     47    void handleMouseDown(const LayoutPoint&, MonotonicTime) override;
     48    void handleMouseMove(const LayoutPoint&, MonotonicTime) override;
     49    void handleMouseUp(const LayoutPoint&, MonotonicTime) override;
    4750
    4851    WeakPtr<ModelPlayerClient> m_client;

  • trunk/Source/WebCore/Modules/model-element/scenekit/SceneKitModelPlayer.h

    r285922 r285986  
    5959    CALayer *layer() override;
    6060    void enterFullscreen() override;
     61    void handleMouseDown(const LayoutPoint&, MonotonicTime) override;
     62    void handleMouseMove(const LayoutPoint&, MonotonicTime) override;
     63    void handleMouseUp(const LayoutPoint&, MonotonicTime) override;
    6164
    6265    // SceneKitModelLoaderClient overrides.

  • trunk/Source/WebCore/Modules/model-element/scenekit/SceneKitModelPlayer.mm

    r285922 r285986  
    7777}
    7878
     79void SceneKitModelPlayer::handleMouseDown(const LayoutPoint&, MonotonicTime)
     80{
     81}
     82
     83void SceneKitModelPlayer::handleMouseMove(const LayoutPoint&, MonotonicTime)
     84{
     85}
     86
     87void SceneKitModelPlayer::handleMouseUp(const LayoutPoint&, MonotonicTime)
     88{
     89}
     90
    7991// MARK: - SceneKitModelLoaderClient overrides.
    8092

  • trunk/Source/WebCore/PAL/ChangeLog

    r285981 r285986  
     12021-11-18  Antoine Quint  <graouts@webkit.org>
     2
     3        [Model] [macOS] Add support for interaction on macOS
     4        https://bugs.webkit.org/show_bug.cgi?id=233105
     5        <rdar://problem/80079386>
     6
     7        Reviewed by Wenson Hsieh.
     8
     9        Add new ARQL SPIs.
     10
     11        * pal/spi/mac/SystemPreviewSPI.h:
     12
    1132021-11-17  Myles C. Maxfield  <mmaxfield@apple.com>
    214

  • trunk/Source/WebCore/PAL/pal/spi/mac/SystemPreviewSPI.h

    r283171 r285986  
    4949- (void)setRemoteContext:(uint32_t)contextId;
    5050
     51- (void)mouseDownAtLocation:(CGPoint)location timestamp:(NSTimeInterval)timestamp;
     52- (void)mouseDraggedAtLocation:(CGPoint)location timestamp:(NSTimeInterval)timestamp;
     53- (void)mouseUpAtLocation:(CGPoint)location timestamp:(NSTimeInterval)timestamp;
     54
    5155@end
    5256

  • trunk/Source/WebKit/ChangeLog

    r285984 r285986  
     12021-11-18  Antoine Quint  <graouts@webkit.org>
     2
     3        [Model] [macOS] Add support for interaction on macOS
     4        https://bugs.webkit.org/show_bug.cgi?id=233105
     5        <rdar://problem/80079386>
     6
     7        Reviewed by Wenson Hsieh.
     8
     9        Forward mouse events captured in the Web process to the matching ASVInlinePreview.
     10
     11        * UIProcess/Cocoa/ModelElementControllerCocoa.mm:
     12        (WebKit::ModelElementController::previewForUUID):
     13        (WebKit::ModelElementController::handleMouseDownForModelElement):
     14        (WebKit::ModelElementController::handleMouseMoveForModelElement):
     15        (WebKit::ModelElementController::handleMouseUpForModelElement):
     16        * UIProcess/ModelElementController.h:
     17        * UIProcess/WebPageProxy.cpp:
     18        (WebKit::WebPageProxy::handleMouseDownForModelElement):
     19        (WebKit::WebPageProxy::handleMouseMoveForModelElement):
     20        (WebKit::WebPageProxy::handleMouseUpForModelElement):
     21        * UIProcess/WebPageProxy.h:
     22        * UIProcess/WebPageProxy.messages.in:
     23        * WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.h:
     24        * WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.mm:
     25        (WebKit::ARKitInlinePreviewModelPlayerIOS::handleMouseDown):
     26        (WebKit::ARKitInlinePreviewModelPlayerIOS::handleMouseMove):
     27        (WebKit::ARKitInlinePreviewModelPlayerIOS::handleMouseUp):
     28        * WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.h:
     29        * WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm:
     30        (WebKit::ARKitInlinePreviewModelPlayerMac::supportsMouseInteraction):
     31        (WebKit::ARKitInlinePreviewModelPlayerMac::handleMouseDown):
     32        (WebKit::ARKitInlinePreviewModelPlayerMac::handleMouseMove):
     33        (WebKit::ARKitInlinePreviewModelPlayerMac::handleMouseUp):
     34
    1352021-11-17  Youenn Fablet  <youenn@apple.com>
    236

  • trunk/Source/WebKit/UIProcess/Cocoa/ModelElementControllerCocoa.mm

    r285637 r285986  
    4343
    4444#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)
     45#import <WebCore/LayoutPoint.h>
     46#import <WebCore/LayoutUnit.h>
    4547#import <WebCore/ResourceError.h>
    4648#import <pal/spi/mac/SystemPreviewSPI.h>
    4749#import <wtf/MainThread.h>
     50#import <wtf/MonotonicTime.h>
    4851#endif
    4952
    … …  
    189192}
    190193
    191 #endif
    192 
    193 }
    194 
    195 #endif
     194RetainPtr<ASVInlinePreview> ModelElementController::previewForUUID(const String& uuid)
     195{
     196    return m_inlinePreviews.get(uuid);
     197}
     198
     199void ModelElementController::handleMouseDownForModelElement(const String& uuid, const WebCore::LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     200{
     201    if (auto preview = previewForUUID(uuid))
     202        [preview mouseDownAtLocation:CGPointMake(locationInPageCoordinates.x().toFloat(), locationInPageCoordinates.y().toFloat()) timestamp:timestamp.secondsSinceEpoch().value()];
     203}
     204
     205void ModelElementController::handleMouseMoveForModelElement(const String& uuid, const WebCore::LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     206{
     207    if (auto preview = previewForUUID(uuid))
     208        [preview mouseDraggedAtLocation:CGPointMake(locationInPageCoordinates.x().toFloat(), locationInPageCoordinates.y().toFloat()) timestamp:timestamp.secondsSinceEpoch().value()];
     209}
     210
     211void ModelElementController::handleMouseUpForModelElement(const String& uuid, const WebCore::LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     212{
     213    if (auto preview = previewForUUID(uuid))
     214        [preview mouseUpAtLocation:CGPointMake(locationInPageCoordinates.x().toFloat(), locationInPageCoordinates.y().toFloat()) timestamp:timestamp.secondsSinceEpoch().value()];
     215}
     216
     217#endif
     218
     219}
     220
     221#endif

  • trunk/Source/WebKit/UIProcess/ModelElementController.h

    r285637 r285986  
    5454#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)
    5555    void modelElementDidCreatePreview(URL, String, WebCore::FloatSize, CompletionHandler<void(Expected<std::pair<String, uint32_t>, WebCore::ResourceError>)>&&);
     56    void handleMouseDownForModelElement(const String&, const WebCore::LayoutPoint&, MonotonicTime);
     57    void handleMouseMoveForModelElement(const String&, const WebCore::LayoutPoint&, MonotonicTime);
     58    void handleMouseUpForModelElement(const String&, const WebCore::LayoutPoint&, MonotonicTime);
    5659#endif
    5760
    … …  
    5962    WebPageProxy& m_webPageProxy;
    6063#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)
     64    RetainPtr<ASVInlinePreview> previewForUUID(const String&);
    6165    HashMap<String, RetainPtr<ASVInlinePreview>> m_inlinePreviews;
    6266#endif

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r285980 r285986  
    1084510845    modelElementController()->modelElementDidCreatePreview(url, uuid, size, WTFMove(completionHandler));
    1084610846}
     10847
     10848void WebPageProxy::handleMouseDownForModelElement(const String& uuid, const WebCore::LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     10849{
     10850    modelElementController()->handleMouseDownForModelElement(uuid, locationInPageCoordinates, timestamp);
     10851}
     10852
     10853void WebPageProxy::handleMouseMoveForModelElement(const String& uuid, const WebCore::LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     10854{
     10855    modelElementController()->handleMouseMoveForModelElement(uuid, locationInPageCoordinates, timestamp);
     10856}
     10857
     10858void WebPageProxy::handleMouseUpForModelElement(const String& uuid, const WebCore::LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     10859{
     10860    modelElementController()->handleMouseUpForModelElement(uuid, locationInPageCoordinates, timestamp);
     10861}
    1084710862#endif
    1084810863

  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r285980 r285986  
    594594#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)
    595595    void modelElementDidCreatePreview(const URL&, const String&, const WebCore::FloatSize&, CompletionHandler<void(Expected<std::pair<String, uint32_t>, WebCore::ResourceError>)>&&);
     596    void handleMouseDownForModelElement(const String&, const WebCore::LayoutPoint&, MonotonicTime);
     597    void handleMouseMoveForModelElement(const String&, const WebCore::LayoutPoint&, MonotonicTime);
     598    void handleMouseUpForModelElement(const String&, const WebCore::LayoutPoint&, MonotonicTime);
    596599#endif
    597600

  • trunk/Source/WebKit/UIProcess/WebPageProxy.messages.in

    r285980 r285986  
    591591#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)
    592592    ModelElementDidCreatePreview(URL url, String uuid, WebCore::FloatSize size) -> (Expected<std::pair<String, uint32_t>, WebCore::ResourceError> result) Async
     593    HandleMouseDownForModelElement(String uuid, WebCore::LayoutPoint locationInPageCoordinates, MonotonicTime timestamp)
     594    HandleMouseMoveForModelElement(String uuid, WebCore::LayoutPoint locationInPageCoordinates, MonotonicTime timestamp)
     595    HandleMouseUpForModelElement(String uuid, WebCore::LayoutPoint locationInPageCoordinates, MonotonicTime timestamp)
    593596#endif
    594597

  • trunk/Source/WebKit/WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.h

    r285922 r285986  
    4444    // WebCore::ModelPlayer overrides.
    4545    void enterFullscreen() override;
     46    void handleMouseDown(const WebCore::LayoutPoint&, MonotonicTime) override;
     47    void handleMouseMove(const WebCore::LayoutPoint&, MonotonicTime) override;
     48    void handleMouseUp(const WebCore::LayoutPoint&, MonotonicTime) override;
    4649};
    4750

  • trunk/Source/WebKit/WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.mm

    r285922 r285986  
    6060}
    6161
     62void ARKitInlinePreviewModelPlayerIOS::handleMouseDown(const WebCore::LayoutPoint&, MonotonicTime)
     63{
     64    ASSERT_NOT_REACHED();
    6265}
    6366
     67void ARKitInlinePreviewModelPlayerIOS::handleMouseMove(const WebCore::LayoutPoint&, MonotonicTime)
     68{
     69    ASSERT_NOT_REACHED();
     70}
     71
     72void ARKitInlinePreviewModelPlayerIOS::handleMouseUp(const WebCore::LayoutPoint&, MonotonicTime)
     73{
     74    ASSERT_NOT_REACHED();
     75}
     76
     77}
    6478#endif

  • trunk/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.h

    r285922 r285986  
    5151    void load(WebCore::Model&, WebCore::LayoutSize) override;
    5252    PlatformLayer* layer() override;
     53    bool supportsMouseInteraction() override;
     54    void handleMouseDown(const WebCore::LayoutPoint&, MonotonicTime) override;
     55    void handleMouseMove(const WebCore::LayoutPoint&, MonotonicTime) override;
     56    void handleMouseUp(const WebCore::LayoutPoint&, MonotonicTime) override;
    5357
    5458    void createFile(WebCore::Model&);

  • trunk/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm

    r285922 r285986  
    171171}
    172172
    173 }
    174 
     173bool ARKitInlinePreviewModelPlayerMac::supportsMouseInteraction()
     174{
     175#if ENABLE(ARKIT_INLINE_PREVIEW_MAC)
     176    return true;
    175177#endif
     178    return false;
     179}
     180
     181void ARKitInlinePreviewModelPlayerMac::handleMouseDown(const LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     182{
     183    if (auto* page = this->page())
     184        page->send(Messages::WebPageProxy::HandleMouseDownForModelElement([m_inlinePreview uuid].UUIDString, locationInPageCoordinates, timestamp));
     185}
     186
     187void ARKitInlinePreviewModelPlayerMac::handleMouseMove(const LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     188{
     189    if (auto* page = this->page())
     190        page->send(Messages::WebPageProxy::HandleMouseMoveForModelElement([m_inlinePreview uuid].UUIDString, locationInPageCoordinates, timestamp));
     191}
     192
     193void ARKitInlinePreviewModelPlayerMac::handleMouseUp(const LayoutPoint& locationInPageCoordinates, MonotonicTime timestamp)
     194{
     195    if (auto* page = this->page())
     196        page->send(Messages::WebPageProxy::HandleMouseUpForModelElement([m_inlinePreview uuid].UUIDString, locationInPageCoordinates, timestamp));
     197}
     198
     199}
     200
     201#endif
Note: See TracChangeset for help on using the changeset viewer.