mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
239 lines
7.8 KiB
C++
239 lines
7.8 KiB
C++
/* -*- 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);
|
|
}
|
|
|
|
// 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");
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
}
|