gecko-dev/widget/windows/InkCollector.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=2 sw=2 et tw=78:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

#include "InkCollector.h"

// Msinkaut_i.c and Msinkaut.h should both be included
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms695519.aspx
#include <msinkaut_i.c>

StaticAutoPtr<InkCollector> InkCollector::sInkCollector;

InkCollector::~InkCollector()
{
  Shutdown();
  MOZ_ASSERT(!mCookie && !mEnabled && !mComInitialized
              && !mMarshaller && !mInkCollector
              && !mConnectionPoint && !mInkCollectorEvent);
}

void InkCollector::Initialize()
{
  // Possibly, we can use mConnectionPoint for checking,
  // But if errors exist (perhaps COM object is unavailable),
  // Initialize() will be called more times.
  static bool sInkCollectorCreated = false;
  if (sInkCollectorCreated) {
    return;
  }
  sInkCollectorCreated = true;

  // COM could get uninitialized due to previous initialization.
  mComInitialized = SUCCEEDED(::CoInitialize(nullptr));

  // Set up instance of InkCollectorEvent.
  mInkCollectorEvent = new InkCollectorEvent();

  // Set up a free threaded marshaler.
  if (FAILED(::CoCreateFreeThreadedMarshaler(mInkCollectorEvent, getter_AddRefs(mMarshaller)))) {
    return;
  }

  // Create the ink collector.
  if (FAILED(::CoCreateInstance(CLSID_InkCollector, NULL, CLSCTX_INPROC_SERVER,
                                IID_IInkCollector, getter_AddRefs(mInkCollector)))) {
    return;
  }

  // Set up connection between sink and InkCollector.
  RefPtr<IConnectionPointContainer> connPointContainer;

  // Get the connection point container.
  if (SUCCEEDED(mInkCollector->QueryInterface(IID_IConnectionPointContainer,
                                              getter_AddRefs(connPointContainer)))) {

    // Find the connection point for Ink Collector events.
    if (SUCCEEDED(connPointContainer->FindConnectionPoint(__uuidof(_IInkCollectorEvents),
                                                          getter_AddRefs(mConnectionPoint)))) {

      // Hook up sink to connection point.
      if (SUCCEEDED(mConnectionPoint->Advise(mInkCollectorEvent, &mCookie))) {
        OnInitialize();
      }
    }
  }
}

void InkCollector::Shutdown()
{
  Enable(false);
  if (mConnectionPoint) {
    // Remove the connection of the sink to the Ink Collector.
    mConnectionPoint->Unadvise(mCookie);
    mCookie = 0;
    mConnectionPoint = nullptr;
  }
  mInkCollector = nullptr;
  mMarshaller = nullptr;
  mInkCollectorEvent = nullptr;

  // Let uninitialization get handled in a place where it got inited.
  if (mComInitialized) {
    CoUninitialize();
    mComInitialized = false;
  }
}

void InkCollector::OnInitialize()
{
  // Suppress all events to do not allow performance decreasing.
  // https://msdn.microsoft.com/en-us/library/ms820347.aspx
  mInkCollector->SetEventInterest(InkCollectorEventInterest::ICEI_AllEvents, VARIANT_FALSE);

  // Sets a value that indicates whether an object or control has interest in a specified event.
  mInkCollector->SetEventInterest(InkCollectorEventInterest::ICEI_CursorOutOfRange, VARIANT_TRUE);

  // If the MousePointer property is set to IMP_Custom and the MouseIcon property is NULL,
  // Then the ink collector no longer handles mouse cursor settings.
  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms700686.aspx
  mInkCollector->put_MouseIcon(nullptr);
  mInkCollector->put_MousePointer(InkMousePointer::IMP_Custom);

  // This mode allows an ink collector to collect ink from any tablet attached to the Tablet PC.
  // The Boolean value that indicates whether to use the mouse as an input device.
  // If TRUE, the mouse is used for input.
  // https://msdn.microsoft.com/en-us/library/ms820346.aspx
  mInkCollector->SetAllTabletsMode(VARIANT_FALSE);

  // Sets the value that specifies whether ink is rendered as it is drawn.
  // VARIANT_TRUE to render ink as it is drawn on the display.
  // VARIANT_FALSE to not have the ink appear on the display as strokes are made.
  // https://msdn.microsoft.com/en-us/library/windows/desktop/dd314598.aspx
  mInkCollector->put_DynamicRendering(VARIANT_FALSE);

  // Set AutoRedraw to false to prevent repainting the ink when the window is
  // invalidated.
  mInkCollector->put_AutoRedraw(VARIANT_FALSE);
}

// Sets a value that specifies whether the InkCollector object collects pen input.
// This property must be set to FALSE before setting or
// calling specific properties and methods of the object.
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms701721.aspx
void InkCollector::Enable(bool aNewState)
{
  if (aNewState != mEnabled) {
    if (mInkCollector) {
      if (SUCCEEDED(mInkCollector->put_Enabled(aNewState ? VARIANT_TRUE : VARIANT_FALSE))) {
        mEnabled = aNewState;
      } else {
        NS_WARNING("InkCollector did not change status successfully");
      }
    } else {
      NS_WARNING("InkCollector should be exist");
    }
  }
}

HWND InkCollector::GetTarget()
{
  return mTargetWindow;
}

void InkCollector::SetTarget(HWND aTargetWindow)
{
  NS_ASSERTION(aTargetWindow, "aTargetWindow should be exist");
  if (aTargetWindow && (aTargetWindow != mTargetWindow)) {
    Initialize();
    if (mInkCollector) {
      Enable(false);
      if (SUCCEEDED(mInkCollector->put_hWnd((LONG_PTR)aTargetWindow))) {
        mTargetWindow = aTargetWindow;
      } else {
        NS_WARNING("InkCollector did not change window property successfully");
      }
      Enable(true);
    }
  }
}

void InkCollector::ClearTarget()
{
  if (mTargetWindow && mInkCollector) {
    Enable(false);
    if (SUCCEEDED(mInkCollector->put_hWnd(0))) {
      mTargetWindow = 0;
    } else {
      NS_WARNING("InkCollector did not clear window property successfully");
    }
  }
}

uint16_t InkCollector::GetPointerId()
{
  return mPointerId;
}

void InkCollector::SetPointerId(uint16_t aPointerId)
{
  mPointerId = aPointerId;
}

void InkCollector::ClearPointerId()
{
  mPointerId = 0;
}

// The display and the digitizer have quite different properties.
// The display has CursorMustTouch, the mouse pointer alway touches the display surface.
// The digitizer lists Integrated and HardProximity.
// When the stylus is in the proximity of the tablet its movements are also detected.
// An external tablet will only list HardProximity.
bool InkCollectorEvent::IsHardProximityTablet(IInkTablet* aTablet) const
{
  if (aTablet) {
    TabletHardwareCapabilities caps;
    if (SUCCEEDED(aTablet->get_HardwareCapabilities(&caps))) {
      return (TabletHardwareCapabilities::THWC_HardProximity & caps);
    }
  }
  return false;
}

HRESULT __stdcall InkCollectorEvent::QueryInterface(REFIID aRiid, void **aObject)
{
  // Validate the input
  if (!aObject) {
    return E_POINTER;
  }
  HRESULT result = E_NOINTERFACE;
  // This object supports IUnknown/IDispatch/IInkCollectorEvents
  if ((IID_IUnknown == aRiid) ||
      (IID_IDispatch == aRiid) ||
      (DIID__IInkCollectorEvents == aRiid)) {
    *aObject = this;
    // AddRef should be called when we give info about interface
    NS_ADDREF_THIS();
    result = S_OK;
  }
  return result;
}

HRESULT InkCollectorEvent::Invoke(DISPID aDispIdMember, REFIID /*aRiid*/,
                                  LCID /*aId*/, WORD /*wFlags*/,
                                  DISPPARAMS* aDispParams, VARIANT* /*aVarResult*/,
                                  EXCEPINFO* /*aExcepInfo*/, UINT* /*aArgErr*/)
{
  switch (aDispIdMember) {
    case DISPID_ICECursorOutOfRange: {
      if (aDispParams && aDispParams->cArgs) {
        CursorOutOfRange(static_cast<IInkCursor*>(aDispParams->rgvarg[0].pdispVal));
      }
      break;
    }
  }
  return S_OK;
}

void InkCollectorEvent::CursorOutOfRange(IInkCursor* aCursor) const
{
  IInkTablet* curTablet = nullptr;
  if (FAILED(aCursor->get_Tablet(&curTablet))) {
    return;
  }
  // All events should be suppressed except
  // from tablets with hard proximity.
  if (!IsHardProximityTablet(curTablet)) {
    return;
  }
  // Notify current target window.
  if (HWND targetWindow = InkCollector::sInkCollector->GetTarget()) {
    ::SendMessage(targetWindow, MOZ_WM_PEN_LEAVES_HOVER_OF_DIGITIZER, 0, 0);
  }
}