widget/windows/DirectManipulationOwner.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "DirectManipulationOwner.h"
   7 #include "nsWindow.h"
   8 #include "WinModifierKeyState.h"
   9 #include "InputData.h"
  10 #include "mozilla/StaticPrefs_apz.h"
  11 #include "mozilla/SwipeTracker.h"
  12 #include "mozilla/TimeStamp.h"
  13 #include "mozilla/VsyncDispatcher.h"
  14
  15 // Direct Manipulation is only defined for Win8 and newer.
  16 #if defined(_WIN32_WINNT)
  17 #  undef _WIN32_WINNT
  18 #  define _WIN32_WINNT _WIN32_WINNT_WIN8
  19 #endif  // defined(_WIN32_WINNT)
  20 #if defined(NTDDI_VERSION)
  21 #  undef NTDDI_VERSION
  22 #  define NTDDI_VERSION NTDDI_WIN8
  23 #endif  // defined(NTDDI_VERSION)
  24
  25 #include "directmanipulation.h"
  26
  27 namespace mozilla {
  28 namespace widget {
  29
  30 class DManipEventHandler : public IDirectManipulationViewportEventHandler,
  31                            public IDirectManipulationInteractionEventHandler {
  32  public:
  33   typedef mozilla::LayoutDeviceIntRect LayoutDeviceIntRect;
  34
  35   friend class DirectManipulationOwner;
  36
  37   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DManipEventHandler)
  38
  39   STDMETHODIMP QueryInterface(REFIID, void**) override;
  40
  41   friend class DirectManipulationOwner;
  42
  43   explicit DManipEventHandler(nsWindow* aWindow,
  44                               DirectManipulationOwner* aOwner,
  45                               const LayoutDeviceIntRect& aBounds);
  46
  47   HRESULT STDMETHODCALLTYPE OnViewportStatusChanged(
  48       IDirectManipulationViewport* viewport, DIRECTMANIPULATION_STATUS current,
  49       DIRECTMANIPULATION_STATUS previous) override;
  50
  51   HRESULT STDMETHODCALLTYPE
  52   OnViewportUpdated(IDirectManipulationViewport* viewport) override;
  53
  54   HRESULT STDMETHODCALLTYPE
  55   OnContentUpdated(IDirectManipulationViewport* viewport,
  56                    IDirectManipulationContent* content) override;
  57
  58   HRESULT STDMETHODCALLTYPE
  59   OnInteraction(IDirectManipulationViewport2* viewport,
  60                 DIRECTMANIPULATION_INTERACTION_TYPE interaction) override;
  61
  62   void Update();
  63
  64   class VObserver final : public mozilla::VsyncObserver {
  65     NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DManipEventHandler::VObserver,
  66                                           override)
  67
  68    public:
  69     void NotifyVsync(const mozilla::VsyncEvent& aVsync) override {
  70       if (mOwner) {
  71         mOwner->Update();
  72       }
  73     }
  74     explicit VObserver(DManipEventHandler* aOwner) : mOwner(aOwner) {}
  75
  76     void ClearOwner() { mOwner = nullptr; }
  77
  78    private:
  79     virtual ~VObserver() {}
  80     DManipEventHandler* mOwner;
  81   };
  82
  83   enum class State { eNone, ePanning, eInertia, ePinching };
  84   void TransitionToState(State aNewState);
  85
  86   enum class Phase { eStart, eMiddle, eEnd };
  87   // Return value indicates if we sent an event or not and hence if we should
  88   // update mLastScale. (We only want to send pinch events if the computed
  89   // deltaY for the corresponding WidgetWheelEvent would be non-zero.)
  90   bool SendPinch(Phase aPhase, float aScale);
  91   void SendPan(Phase aPhase, float x, float y, bool aIsInertia);
  92   static void SendPanCommon(nsWindow* aWindow, Phase aPhase,
  93                             ScreenPoint aPosition, double aDeltaX,
  94                             double aDeltaY, Modifiers aMods, bool aIsInertia);
  95
  96   static void SynthesizeNativeTouchpadPan(
  97       nsWindow* aWindow, nsIWidget::TouchpadGesturePhase aEventPhase,
  98       LayoutDeviceIntPoint aPoint, double aDeltaX, double aDeltaY,
  99       int32_t aModifierFlags);
 100
 101  private:
 102   virtual ~DManipEventHandler() = default;
 103
 104   nsWindow* mWindow;
 105   DirectManipulationOwner* mOwner;
 106   RefPtr<VObserver> mObserver;
 107   float mLastScale;
 108   float mLastXOffset;
 109   float mLastYOffset;
 110   LayoutDeviceIntRect mBounds;
 111   bool mShouldSendPanStart;
 112   bool mShouldSendPinchStart;
 113   State mState = State::eNone;
 114 };
 115
 116 DManipEventHandler::DManipEventHandler(nsWindow* aWindow,
 117                                        DirectManipulationOwner* aOwner,
 118                                        const LayoutDeviceIntRect& aBounds)
 119     : mWindow(aWindow),
 120       mOwner(aOwner),
 121       mLastScale(1.f),
 122       mLastXOffset(0.f),
 123       mLastYOffset(0.f),
 124       mBounds(aBounds),
 125       mShouldSendPanStart(false),
 126       mShouldSendPinchStart(false) {}
 127
 128 STDMETHODIMP
 129 DManipEventHandler::QueryInterface(REFIID iid, void** ppv) {
 130   const IID IID_IDirectManipulationViewportEventHandler =
 131       __uuidof(IDirectManipulationViewportEventHandler);
 132   const IID IID_IDirectManipulationInteractionEventHandler =
 133       __uuidof(IDirectManipulationInteractionEventHandler);
 134
 135   if ((IID_IUnknown == iid) ||
 136       (IID_IDirectManipulationViewportEventHandler == iid)) {
 137     *ppv = static_cast<IDirectManipulationViewportEventHandler*>(this);
 138     AddRef();
 139     return S_OK;
 140   }
 141   if (IID_IDirectManipulationInteractionEventHandler == iid) {
 142     *ppv = static_cast<IDirectManipulationInteractionEventHandler*>(this);
 143     AddRef();
 144     return S_OK;
 145   }
 146
 147   return E_NOINTERFACE;
 148 }
 149
 150 HRESULT
 151 DManipEventHandler::OnViewportStatusChanged(
 152     IDirectManipulationViewport* viewport, DIRECTMANIPULATION_STATUS current,
 153     DIRECTMANIPULATION_STATUS previous) {
 154   if (current == previous) {
 155     return S_OK;
 156   }
 157
 158   if (current == DIRECTMANIPULATION_INERTIA) {
 159     if (previous != DIRECTMANIPULATION_RUNNING || mState != State::ePanning) {
 160       // xxx transition to none?
 161       return S_OK;
 162     }
 163
 164     TransitionToState(State::eInertia);
 165   }
 166
 167   if (current == DIRECTMANIPULATION_RUNNING) {
 168     // INERTIA -> RUNNING, should start a new sequence.
 169     if (previous == DIRECTMANIPULATION_INERTIA) {
 170       TransitionToState(State::eNone);
 171     }
 172   }
 173
 174   if (current != DIRECTMANIPULATION_ENABLED &&
 175       current != DIRECTMANIPULATION_READY) {
 176     return S_OK;
 177   }
 178
 179   // A session has ended, reset the transform.
 180   if (mLastScale != 1.f || mLastXOffset != 0.f || mLastYOffset != 0.f) {
 181     HRESULT hr =
 182         viewport->ZoomToRect(0, 0, mBounds.width, mBounds.height, false);
 183     if (!SUCCEEDED(hr)) {
 184       NS_WARNING("ZoomToRect failed");
 185     }
 186   }
 187   mLastScale = 1.f;
 188   mLastXOffset = 0.f;
 189   mLastYOffset = 0.f;
 190
 191   TransitionToState(State::eNone);
 192
 193   return S_OK;
 194 }
 195
 196 HRESULT
 197 DManipEventHandler::OnViewportUpdated(IDirectManipulationViewport* viewport) {
 198   return S_OK;
 199 }
 200
 201 void DManipEventHandler::TransitionToState(State aNewState) {
 202   if (mState == aNewState) {
 203     return;
 204   }
 205
 206   State prevState = mState;
 207   mState = aNewState;
 208
 209   // End the previous sequence.
 210   switch (prevState) {
 211     case State::ePanning: {
 212       // ePanning -> *: PanEnd
 213       SendPan(Phase::eEnd, 0.f, 0.f, false);
 214       break;
 215     }
 216     case State::eInertia: {
 217       // eInertia -> *: MomentumEnd
 218       SendPan(Phase::eEnd, 0.f, 0.f, true);
 219       break;
 220     }
 221     case State::ePinching: {
 222       MOZ_ASSERT(aNewState == State::eNone);
 223       // ePinching -> eNone: PinchEnd. ePinching should only transition to
 224       // eNone.
 225       // Only send a pinch end if we sent a pinch start.
 226       if (!mShouldSendPinchStart) {
 227         SendPinch(Phase::eEnd, 0.f);
 228       }
 229       mShouldSendPinchStart = false;
 230       break;
 231     }
 232     case State::eNone: {
 233       // eNone -> *: no cleanup is needed.
 234       break;
 235     }
 236     default:
 237       MOZ_ASSERT(false);
 238   }
 239
 240   // Start the new sequence.
 241   switch (aNewState) {
 242     case State::ePanning: {
 243       // eInertia, eNone -> ePanning: PanStart.
 244       // We're being called from OnContentUpdated, it has the coords we need to
 245       // pass to SendPan(Phase::eStart), so set mShouldSendPanStart and when we
 246       // return OnContentUpdated will check it and call SendPan(Phase::eStart).
 247       mShouldSendPanStart = true;
 248       break;
 249     }
 250     case State::eInertia: {
 251       // Only ePanning can transition to eInertia.
 252       MOZ_ASSERT(prevState == State::ePanning);
 253       SendPan(Phase::eStart, 0.f, 0.f, true);
 254       break;
 255     }
 256     case State::ePinching: {
 257       // * -> ePinching: PinchStart.
 258       // Pinch gesture may begin with some scroll events.
 259       // We're being called from OnContentUpdated, it has the scale we need to
 260       // pass to SendPinch(Phase::eStart), so set mShouldSendPinchStart and when
 261       // we return OnContentUpdated will check it and call
 262       // SendPinch(Phase::eStart).
 263       mShouldSendPinchStart = true;
 264       break;
 265     }
 266     case State::eNone: {
 267       // * -> eNone: only cleanup is needed.
 268       break;
 269     }
 270     default:
 271       MOZ_ASSERT(false);
 272   }
 273 }
 274
 275 HRESULT
 276 DManipEventHandler::OnContentUpdated(IDirectManipulationViewport* viewport,
 277                                      IDirectManipulationContent* content) {
 278   float transform[6];
 279   HRESULT hr = content->GetContentTransform(transform, ARRAYSIZE(transform));
 280   if (!SUCCEEDED(hr)) {
 281     NS_WARNING("GetContentTransform failed");
 282     return S_OK;
 283   }
 284
 285   float scale = transform[0];
 286   float xoffset = transform[4];
 287   float yoffset = transform[5];
 288
 289   // Not different from last time.
 290   if (FuzzyEqualsMultiplicative(scale, mLastScale) && xoffset == mLastXOffset &&
 291       yoffset == mLastYOffset) {
 292     return S_OK;
 293   }
 294
 295   // Consider this is a Scroll when scale factor equals 1.0.
 296   if (FuzzyEqualsMultiplicative(scale, 1.f)) {
 297     if (mState == State::eNone) {
 298       TransitionToState(State::ePanning);
 299     }
 300   } else {
 301     // Pinch gesture may begin with some scroll events.
 302     TransitionToState(State::ePinching);
 303   }
 304
 305   if (mState == State::ePanning || mState == State::eInertia) {
 306     // Accumulate the offset (by not updating mLastX/YOffset) until we have at
 307     // least one pixel.
 308     float dx = std::abs(mLastXOffset - xoffset);
 309     float dy = std::abs(mLastYOffset - yoffset);
 310     if (dx < 1.f && dy < 1.f) {
 311       return S_OK;
 312     }
 313   }
 314
 315   bool updateLastScale = true;
 316   if (mState == State::ePanning) {
 317     if (mShouldSendPanStart) {
 318       SendPan(Phase::eStart, mLastXOffset - xoffset, mLastYOffset - yoffset,
 319               false);
 320       mShouldSendPanStart = false;
 321     } else {
 322       SendPan(Phase::eMiddle, mLastXOffset - xoffset, mLastYOffset - yoffset,
 323               false);
 324     }
 325   } else if (mState == State::eInertia) {
 326     SendPan(Phase::eMiddle, mLastXOffset - xoffset, mLastYOffset - yoffset,
 327             true);
 328   } else if (mState == State::ePinching) {
 329     if (mShouldSendPinchStart) {
 330       updateLastScale = SendPinch(Phase::eStart, scale);
 331       // Only clear mShouldSendPinchStart if we actually sent the event
 332       // (updateLastScale tells us if we sent an event).
 333       if (updateLastScale) {
 334         mShouldSendPinchStart = false;
 335       }
 336     } else {
 337       updateLastScale = SendPinch(Phase::eMiddle, scale);
 338     }
 339   }
 340
 341   if (updateLastScale) {
 342     mLastScale = scale;
 343   }
 344   mLastXOffset = xoffset;
 345   mLastYOffset = yoffset;
 346
 347   return S_OK;
 348 }
 349
 350 HRESULT
 351 DManipEventHandler::OnInteraction(
 352     IDirectManipulationViewport2* viewport,
 353     DIRECTMANIPULATION_INTERACTION_TYPE interaction) {
 354   if (interaction == DIRECTMANIPULATION_INTERACTION_BEGIN) {
 355     if (!mObserver) {
 356       mObserver = new VObserver(this);
 357     }
 358
 359     gfxWindowsPlatform::GetPlatform()
 360         ->GetGlobalVsyncDispatcher()
 361         ->AddMainThreadObserver(mObserver);
 362   }
 363
 364   if (mObserver && interaction == DIRECTMANIPULATION_INTERACTION_END) {
 365     gfxWindowsPlatform::GetPlatform()
 366         ->GetGlobalVsyncDispatcher()
 367         ->RemoveMainThreadObserver(mObserver);
 368   }
 369
 370   return S_OK;
 371 }
 372
 373 void DManipEventHandler::Update() {
 374   if (mOwner) {
 375     mOwner->Update();
 376   }
 377 }
 378
 379 void DirectManipulationOwner::Update() {
 380   if (mDmUpdateManager) {
 381     mDmUpdateManager->Update(nullptr);
 382   }
 383 }
 384
 385 DirectManipulationOwner::DirectManipulationOwner(nsWindow* aWindow)
 386     : mWindow(aWindow) {}
 387
 388 DirectManipulationOwner::~DirectManipulationOwner() { Destroy(); }
 389
 390 bool DManipEventHandler::SendPinch(Phase aPhase, float aScale) {
 391   if (!mWindow) {
 392     return false;
 393   }
 394
 395   if (aScale == mLastScale && aPhase != Phase::eEnd) {
 396     return false;
 397   }
 398
 399   PinchGestureInput::PinchGestureType pinchGestureType =
 400       PinchGestureInput::PINCHGESTURE_SCALE;
 401   switch (aPhase) {
 402     case Phase::eStart:
 403       pinchGestureType = PinchGestureInput::PINCHGESTURE_START;
 404       break;
 405     case Phase::eMiddle:
 406       pinchGestureType = PinchGestureInput::PINCHGESTURE_SCALE;
 407       break;
 408     case Phase::eEnd:
 409       pinchGestureType = PinchGestureInput::PINCHGESTURE_END;
 410       break;
 411     default:
 412       MOZ_ASSERT_UNREACHABLE("handle all enum values");
 413   }
 414
 415   TimeStamp eventTimeStamp = TimeStamp::Now();
 416
 417   ModifierKeyState modifierKeyState;
 418   Modifiers mods = modifierKeyState.GetModifiers();
 419
 420   ExternalPoint screenOffset = ViewAs<ExternalPixel>(
 421       mWindow->WidgetToScreenOffset(),
 422       PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent);
 423
 424   POINT cursor_pos;
 425   ::GetCursorPos(&cursor_pos);
 426   HWND wnd = static_cast<HWND>(mWindow->GetNativeData(NS_NATIVE_WINDOW));
 427   ::ScreenToClient(wnd, &cursor_pos);
 428   ScreenPoint position = {(float)cursor_pos.x, (float)cursor_pos.y};
 429
 430   PinchGestureInput event{pinchGestureType,
 431                           PinchGestureInput::TRACKPAD,
 432                           eventTimeStamp,
 433                           screenOffset,
 434                           position,
 435                           100.0 * ((aPhase == Phase::eEnd) ? 1.f : aScale),
 436                           100.0 * ((aPhase == Phase::eEnd) ? 1.f : mLastScale),
 437                           mods};
 438
 439   if (!event.SetLineOrPageDeltaY(mWindow)) {
 440     return false;
 441   }
 442
 443   mWindow->SendAnAPZEvent(event);
 444
 445   return true;
 446 }
 447
 448 void DManipEventHandler::SendPan(Phase aPhase, float x, float y,
 449                                  bool aIsInertia) {
 450   if (!mWindow) {
 451     return;
 452   }
 453
 454   ModifierKeyState modifierKeyState;
 455   Modifiers mods = modifierKeyState.GetModifiers();
 456
 457   POINT cursor_pos;
 458   ::GetCursorPos(&cursor_pos);
 459   HWND wnd = static_cast<HWND>(mWindow->GetNativeData(NS_NATIVE_WINDOW));
 460   ::ScreenToClient(wnd, &cursor_pos);
 461   ScreenPoint position = {(float)cursor_pos.x, (float)cursor_pos.y};
 462
 463   SendPanCommon(mWindow, aPhase, position, x, y, mods, aIsInertia);
 464 }
 465
 466 /* static */
 467 void DManipEventHandler::SendPanCommon(nsWindow* aWindow, Phase aPhase,
 468                                        ScreenPoint aPosition, double aDeltaX,
 469                                        double aDeltaY, Modifiers aMods,
 470                                        bool aIsInertia) {
 471   if (!aWindow) {
 472     return;
 473   }
 474
 475   PanGestureInput::PanGestureType panGestureType =
 476       PanGestureInput::PANGESTURE_PAN;
 477   if (aIsInertia) {
 478     switch (aPhase) {
 479       case Phase::eStart:
 480         panGestureType = PanGestureInput::PANGESTURE_MOMENTUMSTART;
 481         break;
 482       case Phase::eMiddle:
 483         panGestureType = PanGestureInput::PANGESTURE_MOMENTUMPAN;
 484         break;
 485       case Phase::eEnd:
 486         panGestureType = PanGestureInput::PANGESTURE_MOMENTUMEND;
 487         break;
 488       default:
 489         MOZ_ASSERT_UNREACHABLE("handle all enum values");
 490     }
 491   } else {
 492     switch (aPhase) {
 493       case Phase::eStart:
 494         panGestureType = PanGestureInput::PANGESTURE_START;
 495         break;
 496       case Phase::eMiddle:
 497         panGestureType = PanGestureInput::PANGESTURE_PAN;
 498         break;
 499       case Phase::eEnd:
 500         panGestureType = PanGestureInput::PANGESTURE_END;
 501         break;
 502       default:
 503         MOZ_ASSERT_UNREACHABLE("handle all enum values");
 504     }
 505   }
 506
 507   TimeStamp eventTimeStamp = TimeStamp::Now();
 508
 509   PanGestureInput event{panGestureType, eventTimeStamp, aPosition,
 510                         ScreenPoint(aDeltaX, aDeltaY), aMods};
 511
 512   aWindow->SendAnAPZEvent(event);
 513 }
 514
 515 void DirectManipulationOwner::Init(const LayoutDeviceIntRect& aBounds) {
 516   HRESULT hr = CoCreateInstance(
 517       CLSID_DirectManipulationManager, nullptr, CLSCTX_INPROC_SERVER,
 518       IID_IDirectManipulationManager, getter_AddRefs(mDmManager));
 519   if (!SUCCEEDED(hr)) {
 520     NS_WARNING("CoCreateInstance(CLSID_DirectManipulationManager failed");
 521     mDmManager = nullptr;
 522     return;
 523   }
 524
 525   hr = mDmManager->GetUpdateManager(IID_IDirectManipulationUpdateManager,
 526                                     getter_AddRefs(mDmUpdateManager));
 527   if (!SUCCEEDED(hr)) {
 528     NS_WARNING("GetUpdateManager failed");
 529     mDmManager = nullptr;
 530     mDmUpdateManager = nullptr;
 531     return;
 532   }
 533
 534   HWND wnd = static_cast<HWND>(mWindow->GetNativeData(NS_NATIVE_WINDOW));
 535
 536   hr = mDmManager->CreateViewport(nullptr, wnd, IID_IDirectManipulationViewport,
 537                                   getter_AddRefs(mDmViewport));
 538   if (!SUCCEEDED(hr)) {
 539     NS_WARNING("CreateViewport failed");
 540     mDmManager = nullptr;
 541     mDmUpdateManager = nullptr;
 542     mDmViewport = nullptr;
 543     return;
 544   }
 545
 546   DIRECTMANIPULATION_CONFIGURATION configuration =
 547       DIRECTMANIPULATION_CONFIGURATION_INTERACTION |
 548       DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_X |
 549       DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_Y |
 550       DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_INERTIA |
 551       DIRECTMANIPULATION_CONFIGURATION_RAILS_X |
 552       DIRECTMANIPULATION_CONFIGURATION_RAILS_Y;
 553   if (StaticPrefs::apz_allow_zooming()) {
 554     configuration |= DIRECTMANIPULATION_CONFIGURATION_SCALING;
 555   }
 556
 557   hr = mDmViewport->ActivateConfiguration(configuration);
 558   if (!SUCCEEDED(hr)) {
 559     NS_WARNING("ActivateConfiguration failed");
 560     mDmManager = nullptr;
 561     mDmUpdateManager = nullptr;
 562     mDmViewport = nullptr;
 563     return;
 564   }
 565
 566   hr = mDmViewport->SetViewportOptions(
 567       DIRECTMANIPULATION_VIEWPORT_OPTIONS_MANUALUPDATE);
 568   if (!SUCCEEDED(hr)) {
 569     NS_WARNING("SetViewportOptions failed");
 570     mDmManager = nullptr;
 571     mDmUpdateManager = nullptr;
 572     mDmViewport = nullptr;
 573     return;
 574   }
 575
 576   mDmHandler = new DManipEventHandler(mWindow, this, aBounds);
 577
 578   hr = mDmViewport->AddEventHandler(wnd, mDmHandler.get(),
 579                                     &mDmViewportHandlerCookie);
 580   if (!SUCCEEDED(hr)) {
 581     NS_WARNING("AddEventHandler failed");
 582     mDmManager = nullptr;
 583     mDmUpdateManager = nullptr;
 584     mDmViewport = nullptr;
 585     mDmHandler = nullptr;
 586     return;
 587   }
 588
 589   RECT rect = {0, 0, aBounds.Width(), aBounds.Height()};
 590   hr = mDmViewport->SetViewportRect(&rect);
 591   if (!SUCCEEDED(hr)) {
 592     NS_WARNING("SetViewportRect failed");
 593     mDmManager = nullptr;
 594     mDmUpdateManager = nullptr;
 595     mDmViewport = nullptr;
 596     mDmHandler = nullptr;
 597     return;
 598   }
 599
 600   hr = mDmManager->Activate(wnd);
 601   if (!SUCCEEDED(hr)) {
 602     NS_WARNING("manager Activate failed");
 603     mDmManager = nullptr;
 604     mDmUpdateManager = nullptr;
 605     mDmViewport = nullptr;
 606     mDmHandler = nullptr;
 607     return;
 608   }
 609
 610   hr = mDmViewport->Enable();
 611   if (!SUCCEEDED(hr)) {
 612     NS_WARNING("mDmViewport->Enable failed");
 613     mDmManager = nullptr;
 614     mDmUpdateManager = nullptr;
 615     mDmViewport = nullptr;
 616     mDmHandler = nullptr;
 617     return;
 618   }
 619
 620   hr = mDmUpdateManager->Update(nullptr);
 621   if (!SUCCEEDED(hr)) {
 622     NS_WARNING("mDmUpdateManager->Update failed");
 623     mDmManager = nullptr;
 624     mDmUpdateManager = nullptr;
 625     mDmViewport = nullptr;
 626     mDmHandler = nullptr;
 627     return;
 628   }
 629 }
 630
 631 void DirectManipulationOwner::ResizeViewport(
 632     const LayoutDeviceIntRect& aBounds) {
 633   if (mDmHandler) {
 634     mDmHandler->mBounds = aBounds;
 635   }
 636
 637   if (mDmViewport) {
 638     RECT rect = {0, 0, aBounds.Width(), aBounds.Height()};
 639     HRESULT hr = mDmViewport->SetViewportRect(&rect);
 640     if (!SUCCEEDED(hr)) {
 641       NS_WARNING("SetViewportRect failed");
 642     }
 643   }
 644 }
 645
 646 void DirectManipulationOwner::Destroy() {
 647   if (mDmHandler) {
 648     mDmHandler->mWindow = nullptr;
 649     mDmHandler->mOwner = nullptr;
 650     if (mDmHandler->mObserver) {
 651       gfxWindowsPlatform::GetPlatform()
 652           ->GetGlobalVsyncDispatcher()
 653           ->RemoveMainThreadObserver(mDmHandler->mObserver);
 654       mDmHandler->mObserver->ClearOwner();
 655       mDmHandler->mObserver = nullptr;
 656     }
 657   }
 658
 659   HRESULT hr;
 660   if (mDmViewport) {
 661     hr = mDmViewport->Stop();
 662     if (!SUCCEEDED(hr)) {
 663       NS_WARNING("mDmViewport->Stop() failed");
 664     }
 665
 666     hr = mDmViewport->Disable();
 667     if (!SUCCEEDED(hr)) {
 668       NS_WARNING("mDmViewport->Disable() failed");
 669     }
 670
 671     hr = mDmViewport->RemoveEventHandler(mDmViewportHandlerCookie);
 672     if (!SUCCEEDED(hr)) {
 673       NS_WARNING("mDmViewport->RemoveEventHandler() failed");
 674     }
 675
 676     hr = mDmViewport->Abandon();
 677     if (!SUCCEEDED(hr)) {
 678       NS_WARNING("mDmViewport->Abandon() failed");
 679     }
 680   }
 681
 682   if (mWindow) {
 683     HWND wnd = static_cast<HWND>(mWindow->GetNativeData(NS_NATIVE_WINDOW));
 684
 685     if (mDmManager) {
 686       hr = mDmManager->Deactivate(wnd);
 687       if (!SUCCEEDED(hr)) {
 688         NS_WARNING("mDmManager->Deactivate() failed");
 689       }
 690     }
 691   }
 692
 693   mDmHandler = nullptr;
 694   mDmViewport = nullptr;
 695   mDmUpdateManager = nullptr;
 696   mDmManager = nullptr;
 697   mWindow = nullptr;
 698 }
 699
 700 void DirectManipulationOwner::SetContact(UINT aContactId) {
 701   if (mDmViewport) {
 702     mDmViewport->SetContact(aContactId);
 703   }
 704 }
 705
 706 /*static  */ void DirectManipulationOwner::SynthesizeNativeTouchpadPan(
 707     nsWindow* aWindow, nsIWidget::TouchpadGesturePhase aEventPhase,
 708     LayoutDeviceIntPoint aPoint, double aDeltaX, double aDeltaY,
 709     int32_t aModifierFlags) {
 710   DManipEventHandler::SynthesizeNativeTouchpadPan(
 711       aWindow, aEventPhase, aPoint, aDeltaX, aDeltaY, aModifierFlags);
 712 }
 713
 714 /*static  */ void DManipEventHandler::SynthesizeNativeTouchpadPan(
 715     nsWindow* aWindow, nsIWidget::TouchpadGesturePhase aEventPhase,
 716     LayoutDeviceIntPoint aPoint, double aDeltaX, double aDeltaY,
 717     int32_t aModifierFlags) {
 718   ScreenPoint position = {(float)aPoint.x, (float)aPoint.y};
 719   Phase phase = Phase::eStart;
 720   if (aEventPhase == nsIWidget::PHASE_UPDATE) {
 721     phase = Phase::eMiddle;
 722   }
 723
 724   if (aEventPhase == nsIWidget::PHASE_END) {
 725     phase = Phase::eEnd;
 726   }
 727   SendPanCommon(aWindow, phase, position, aDeltaX, aDeltaY, aModifierFlags,
 728                 /* aIsInertia = */ false);
 729 }
 730
 731 }  // namespace widget
 732 }  // namespace mozilla