2004-08-20 18:09:19 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2004-08-20 18:09:19 +00:00
|
|
|
|
2009-11-17 14:22:23 +00:00
|
|
|
#include "base/basictypes.h"
|
|
|
|
#include "IPC/IPCMessageUtils.h"
|
2004-08-20 18:09:19 +00:00
|
|
|
#include "nsCOMPtr.h"
|
|
|
|
#include "nsDOMUIEvent.h"
|
|
|
|
#include "nsIPresShell.h"
|
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
2011-07-15 10:31:34 +00:00
|
|
|
#include "nsIDOMWindow.h"
|
2004-08-20 18:09:19 +00:00
|
|
|
#include "nsIDOMNode.h"
|
|
|
|
#include "nsIContent.h"
|
|
|
|
#include "nsContentUtils.h"
|
2011-04-21 17:35:52 +00:00
|
|
|
#include "nsEventStateManager.h"
|
2004-08-20 18:09:19 +00:00
|
|
|
#include "nsIFrame.h"
|
2007-02-18 10:43:12 +00:00
|
|
|
#include "nsIScrollableFrame.h"
|
2011-12-23 22:13:46 +00:00
|
|
|
#include "DictionaryHelpers.h"
|
2012-04-25 03:00:01 +00:00
|
|
|
#include "mozilla/Util.h"
|
|
|
|
#include "mozilla/Assertions.h"
|
|
|
|
|
|
|
|
using namespace mozilla;
|
2004-08-20 18:09:19 +00:00
|
|
|
|
|
|
|
nsDOMUIEvent::nsDOMUIEvent(nsPresContext* aPresContext, nsGUIEvent* aEvent)
|
2005-04-28 23:48:28 +00:00
|
|
|
: nsDOMEvent(aPresContext, aEvent ?
|
2007-07-08 07:08:04 +00:00
|
|
|
static_cast<nsEvent *>(aEvent) :
|
2011-10-17 14:59:28 +00:00
|
|
|
static_cast<nsEvent *>(new nsUIEvent(false, 0, 0)))
|
2012-05-09 22:54:18 +00:00
|
|
|
, mClientPoint(0, 0), mLayerPoint(0, 0), mPagePoint(0, 0), mMovementPoint(0, 0)
|
2012-04-11 21:55:21 +00:00
|
|
|
, mIsPointerLocked(nsEventStateManager::sIsPointerLocked)
|
|
|
|
, mLastScreenPoint(nsEventStateManager::sLastScreenPoint)
|
|
|
|
, mLastClientPoint(nsEventStateManager::sLastClientPoint)
|
2004-08-20 18:09:19 +00:00
|
|
|
{
|
|
|
|
if (aEvent) {
|
2011-10-17 14:59:28 +00:00
|
|
|
mEventIsInternal = false;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
else {
|
2011-10-17 14:59:28 +00:00
|
|
|
mEventIsInternal = true;
|
2004-08-20 18:09:19 +00:00
|
|
|
mEvent->time = PR_Now();
|
|
|
|
}
|
|
|
|
|
2005-04-28 23:48:28 +00:00
|
|
|
// Fill mDetail and mView according to the mEvent (widget-generated
|
|
|
|
// event) we've got
|
2004-08-20 18:09:19 +00:00
|
|
|
switch(mEvent->eventStructType)
|
|
|
|
{
|
|
|
|
case NS_UI_EVENT:
|
|
|
|
{
|
2007-07-08 07:08:04 +00:00
|
|
|
nsUIEvent *event = static_cast<nsUIEvent*>(mEvent);
|
2004-08-20 18:09:19 +00:00
|
|
|
mDetail = event->detail;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case NS_SCROLLPORT_EVENT:
|
|
|
|
{
|
2007-07-08 07:08:04 +00:00
|
|
|
nsScrollPortEvent* scrollEvent = static_cast<nsScrollPortEvent*>(mEvent);
|
2004-08-20 18:09:19 +00:00
|
|
|
mDetail = (PRInt32)scrollEvent->orient;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
mDetail = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
mView = nsnull;
|
|
|
|
if (mPresContext)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsISupports> container = mPresContext->GetContainer();
|
|
|
|
if (container)
|
|
|
|
{
|
2011-07-15 10:31:34 +00:00
|
|
|
nsCOMPtr<nsIDOMWindow> window = do_GetInterface(container);
|
2004-08-20 18:09:19 +00:00
|
|
|
if (window)
|
|
|
|
mView = do_QueryInterface(window);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-26 08:21:42 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMUIEvent)
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsDOMUIEvent, nsDOMEvent)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mView)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsDOMUIEvent, nsDOMEvent)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mView)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
2004-08-20 18:09:19 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsDOMUIEvent, nsDOMEvent)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsDOMUIEvent, nsDOMEvent)
|
|
|
|
|
2010-01-12 13:08:43 +00:00
|
|
|
DOMCI_DATA(UIEvent, nsDOMUIEvent)
|
|
|
|
|
2007-06-26 08:21:42 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsDOMUIEvent)
|
2004-08-20 18:09:19 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMUIEvent)
|
2010-03-17 15:09:05 +00:00
|
|
|
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(UIEvent)
|
2004-08-20 18:09:19 +00:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsDOMEvent)
|
|
|
|
|
2009-01-15 03:27:09 +00:00
|
|
|
nsIntPoint
|
2012-04-11 21:55:21 +00:00
|
|
|
nsDOMUIEvent::GetMovementPoint()
|
2009-01-15 03:27:09 +00:00
|
|
|
{
|
2012-05-09 22:54:18 +00:00
|
|
|
if (mPrivateDataDuplicated) {
|
|
|
|
return mMovementPoint;
|
|
|
|
}
|
|
|
|
|
2012-04-11 21:55:21 +00:00
|
|
|
if (!mEvent ||
|
2008-08-27 12:07:27 +00:00
|
|
|
(mEvent->eventStructType != NS_MOUSE_EVENT &&
|
|
|
|
mEvent->eventStructType != NS_POPUP_EVENT &&
|
|
|
|
mEvent->eventStructType != NS_MOUSE_SCROLL_EVENT &&
|
2010-08-02 13:34:54 +00:00
|
|
|
mEvent->eventStructType != NS_MOZTOUCH_EVENT &&
|
2009-02-17 11:49:03 +00:00
|
|
|
mEvent->eventStructType != NS_DRAG_EVENT &&
|
|
|
|
mEvent->eventStructType != NS_SIMPLE_GESTURE_EVENT)) {
|
2009-01-15 03:27:09 +00:00
|
|
|
return nsIntPoint(0, 0);
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
2012-04-11 21:55:21 +00:00
|
|
|
if (!((nsGUIEvent*)mEvent)->widget) {
|
|
|
|
return mEvent->lastRefPoint;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
2007-07-26 03:34:16 +00:00
|
|
|
|
2012-04-11 21:55:21 +00:00
|
|
|
// Calculate the delta between the previous screen point and the current one.
|
|
|
|
nsIntPoint currentPoint = CalculateScreenPoint(mPresContext, mEvent);
|
|
|
|
|
|
|
|
// Adjust previous event's refPoint so it compares to current screenX, screenY
|
|
|
|
nsIntPoint offset = mEvent->lastRefPoint +
|
2009-02-19 00:11:49 +00:00
|
|
|
((nsGUIEvent*)mEvent)->widget->WidgetToScreenOffset();
|
2009-01-15 03:27:09 +00:00
|
|
|
nscoord factor = mPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();
|
2012-04-11 21:55:21 +00:00
|
|
|
nsIntPoint lastPoint = nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(offset.x * factor),
|
|
|
|
nsPresContext::AppUnitsToIntCSSPixels(offset.y * factor));
|
|
|
|
|
|
|
|
return currentPoint - lastPoint;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
2009-01-15 03:27:09 +00:00
|
|
|
nsIntPoint
|
2012-04-11 21:55:21 +00:00
|
|
|
nsDOMUIEvent::GetScreenPoint()
|
2009-01-15 03:27:09 +00:00
|
|
|
{
|
2012-04-11 21:55:21 +00:00
|
|
|
if (mIsPointerLocked) {
|
|
|
|
return mLastScreenPoint;
|
2007-11-12 12:53:06 +00:00
|
|
|
}
|
2007-08-04 01:12:24 +00:00
|
|
|
|
2012-04-11 21:55:21 +00:00
|
|
|
return CalculateScreenPoint(mPresContext, mEvent);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIntPoint
|
|
|
|
nsDOMUIEvent::GetClientPoint()
|
|
|
|
{
|
|
|
|
if (mIsPointerLocked) {
|
|
|
|
return mLastClientPoint;
|
2007-11-12 19:09:09 +00:00
|
|
|
}
|
2005-07-19 21:07:47 +00:00
|
|
|
|
2012-04-11 21:55:21 +00:00
|
|
|
return CalculateClientPoint(mPresContext, mEvent, &mClientPoint);
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-04-24 06:54:25 +00:00
|
|
|
nsDOMUIEvent::GetView(nsIDOMWindow** aView)
|
2004-08-20 18:09:19 +00:00
|
|
|
{
|
|
|
|
*aView = mView;
|
|
|
|
NS_IF_ADDREF(*aView);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetDetail(PRInt32* aDetail)
|
|
|
|
{
|
|
|
|
*aDetail = mDetail;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-04-24 06:54:25 +00:00
|
|
|
nsDOMUIEvent::InitUIEvent(const nsAString& typeArg,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool canBubbleArg,
|
|
|
|
bool cancelableArg,
|
2011-04-24 06:54:25 +00:00
|
|
|
nsIDOMWindow* viewArg,
|
|
|
|
PRInt32 detailArg)
|
2004-08-20 18:09:19 +00:00
|
|
|
{
|
|
|
|
nsresult rv = nsDOMEvent::InitEvent(typeArg, canBubbleArg, cancelableArg);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
mDetail = detailArg;
|
|
|
|
mView = viewArg;
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-14 20:36:46 +00:00
|
|
|
nsresult
|
2011-12-23 22:13:46 +00:00
|
|
|
nsDOMUIEvent::InitFromCtor(const nsAString& aType,
|
|
|
|
JSContext* aCx, jsval* aVal)
|
2011-12-14 20:36:46 +00:00
|
|
|
{
|
2011-12-23 22:13:46 +00:00
|
|
|
mozilla::dom::UIEventInit d;
|
|
|
|
nsresult rv = d.Init(aCx, aVal);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return InitUIEvent(aType, d.bubbles, d.cancelable, d.view, d.detail);
|
2011-12-14 20:36:46 +00:00
|
|
|
}
|
|
|
|
|
2004-08-20 18:09:19 +00:00
|
|
|
// ---- nsDOMNSUIEvent implementation -------------------
|
2009-01-15 03:27:09 +00:00
|
|
|
nsIntPoint
|
2007-02-18 10:43:12 +00:00
|
|
|
nsDOMUIEvent::GetPagePoint()
|
|
|
|
{
|
2008-07-13 19:48:37 +00:00
|
|
|
if (mPrivateDataDuplicated) {
|
|
|
|
return mPagePoint;
|
|
|
|
}
|
|
|
|
|
2009-01-15 03:27:09 +00:00
|
|
|
nsIntPoint pagePoint = GetClientPoint();
|
2008-07-13 19:48:37 +00:00
|
|
|
|
|
|
|
// If there is some scrolling, add scroll info to client point.
|
|
|
|
if (mPresContext && mPresContext->GetPresShell()) {
|
2008-03-01 18:49:54 +00:00
|
|
|
nsIPresShell* shell = mPresContext->GetPresShell();
|
2007-11-12 19:09:09 +00:00
|
|
|
nsIScrollableFrame* scrollframe = shell->GetRootScrollFrameAsScrollable();
|
2008-07-13 19:48:37 +00:00
|
|
|
if (scrollframe) {
|
|
|
|
nsPoint pt = scrollframe->GetScrollPosition();
|
2009-01-15 03:27:09 +00:00
|
|
|
pagePoint += nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(pt.x),
|
|
|
|
nsPresContext::AppUnitsToIntCSSPixels(pt.y));
|
2008-07-13 19:48:37 +00:00
|
|
|
}
|
2007-02-18 10:43:12 +00:00
|
|
|
}
|
|
|
|
|
2008-07-13 19:48:37 +00:00
|
|
|
return pagePoint;
|
2007-02-18 10:43:12 +00:00
|
|
|
}
|
|
|
|
|
2004-08-20 18:09:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetPageX(PRInt32* aPageX)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPageX);
|
2011-12-17 00:24:11 +00:00
|
|
|
if (mPrivateDataDuplicated) {
|
|
|
|
*aPageX = mPagePoint.x;
|
|
|
|
} else {
|
|
|
|
*aPageX = nsDOMEvent::GetPageCoords(mPresContext,
|
|
|
|
mEvent,
|
|
|
|
mEvent->refPoint,
|
|
|
|
mClientPoint).x;
|
|
|
|
}
|
2007-02-18 10:43:12 +00:00
|
|
|
return NS_OK;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetPageY(PRInt32* aPageY)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aPageY);
|
2011-12-17 00:24:11 +00:00
|
|
|
if (mPrivateDataDuplicated) {
|
|
|
|
*aPageY = mPagePoint.y;
|
|
|
|
} else {
|
|
|
|
*aPageY = nsDOMEvent::GetPageCoords(mPresContext,
|
|
|
|
mEvent,
|
|
|
|
mEvent->refPoint,
|
|
|
|
mClientPoint).y;
|
|
|
|
}
|
2007-02-18 10:43:12 +00:00
|
|
|
return NS_OK;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetWhich(PRUint32* aWhich)
|
|
|
|
{
|
2011-08-26 07:43:49 +00:00
|
|
|
return Which(aWhich);
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetRangeParent(nsIDOMNode** aRangeParent)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aRangeParent);
|
|
|
|
nsIFrame* targetFrame = nsnull;
|
|
|
|
|
|
|
|
if (mPresContext) {
|
2011-04-21 17:35:52 +00:00
|
|
|
targetFrame = mPresContext->EventStateManager()->GetEventTarget();
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*aRangeParent = nsnull;
|
|
|
|
|
|
|
|
if (targetFrame) {
|
2005-09-04 20:04:23 +00:00
|
|
|
nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mEvent,
|
2006-02-27 05:57:37 +00:00
|
|
|
targetFrame);
|
|
|
|
nsCOMPtr<nsIContent> parent = targetFrame->GetContentOffsetsFromPoint(pt).content;
|
|
|
|
if (parent) {
|
2011-01-29 11:32:19 +00:00
|
|
|
if (parent->IsInNativeAnonymousSubtree() &&
|
|
|
|
!nsContentUtils::CanAccessNativeAnon()) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2006-02-27 05:57:37 +00:00
|
|
|
return CallQueryInterface(parent, aRangeParent);
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetRangeOffset(PRInt32* aRangeOffset)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aRangeOffset);
|
|
|
|
nsIFrame* targetFrame = nsnull;
|
|
|
|
|
|
|
|
if (mPresContext) {
|
2011-04-21 17:35:52 +00:00
|
|
|
targetFrame = mPresContext->EventStateManager()->GetEventTarget();
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (targetFrame) {
|
2005-09-04 20:04:23 +00:00
|
|
|
nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mEvent,
|
2006-02-27 05:57:37 +00:00
|
|
|
targetFrame);
|
|
|
|
*aRangeOffset = targetFrame->GetContentOffsetsFromPoint(pt).offset;
|
|
|
|
return NS_OK;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
*aRangeOffset = 0;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMUIEvent::GetCancelBubble(bool* aCancelBubble)
|
2004-08-20 18:09:19 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aCancelBubble);
|
2006-04-10 17:04:54 +00:00
|
|
|
*aCancelBubble =
|
2011-10-17 14:59:28 +00:00
|
|
|
(mEvent->flags & NS_EVENT_FLAG_STOP_DISPATCH) ? true : false;
|
2004-08-20 18:09:19 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMUIEvent::SetCancelBubble(bool aCancelBubble)
|
2004-08-20 18:09:19 +00:00
|
|
|
{
|
2006-04-10 17:04:54 +00:00
|
|
|
if (aCancelBubble) {
|
|
|
|
mEvent->flags |= NS_EVENT_FLAG_STOP_DISPATCH;
|
|
|
|
} else {
|
|
|
|
mEvent->flags &= ~NS_EVENT_FLAG_STOP_DISPATCH;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-01-15 03:27:09 +00:00
|
|
|
nsIntPoint
|
|
|
|
nsDOMUIEvent::GetLayerPoint()
|
|
|
|
{
|
2007-02-20 14:57:52 +00:00
|
|
|
if (!mEvent ||
|
|
|
|
(mEvent->eventStructType != NS_MOUSE_EVENT &&
|
2008-09-03 15:51:24 +00:00
|
|
|
mEvent->eventStructType != NS_POPUP_EVENT &&
|
|
|
|
mEvent->eventStructType != NS_MOUSE_SCROLL_EVENT &&
|
2010-08-02 13:34:54 +00:00
|
|
|
mEvent->eventStructType != NS_MOZTOUCH_EVENT &&
|
2011-12-17 00:24:11 +00:00
|
|
|
mEvent->eventStructType != NS_TOUCH_EVENT &&
|
2009-02-17 11:49:03 +00:00
|
|
|
mEvent->eventStructType != NS_DRAG_EVENT &&
|
|
|
|
mEvent->eventStructType != NS_SIMPLE_GESTURE_EVENT) ||
|
2007-11-12 12:53:06 +00:00
|
|
|
!mPresContext ||
|
|
|
|
mEventIsInternal) {
|
|
|
|
return mLayerPoint;
|
2004-08-20 18:09:19 +00:00
|
|
|
}
|
2007-02-18 10:43:12 +00:00
|
|
|
// XXX I'm not really sure this is correct; it's my best shot, though
|
2011-04-21 17:35:52 +00:00
|
|
|
nsIFrame* targetFrame = mPresContext->EventStateManager()->GetEventTarget();
|
2007-02-18 10:43:12 +00:00
|
|
|
if (!targetFrame)
|
2007-11-12 12:53:06 +00:00
|
|
|
return mLayerPoint;
|
2007-02-18 10:43:12 +00:00
|
|
|
nsIFrame* layer = nsLayoutUtils::GetClosestLayer(targetFrame);
|
|
|
|
nsPoint pt(nsLayoutUtils::GetEventCoordinatesRelativeTo(mEvent, layer));
|
2009-01-15 03:27:09 +00:00
|
|
|
return nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(pt.x),
|
|
|
|
nsPresContext::AppUnitsToIntCSSPixels(pt.y));
|
2005-08-23 03:57:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetLayerX(PRInt32* aLayerX)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aLayerX);
|
|
|
|
*aLayerX = GetLayerPoint().x;
|
2004-08-20 18:09:19 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMUIEvent::GetLayerY(PRInt32* aLayerY)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aLayerY);
|
2005-08-23 03:57:07 +00:00
|
|
|
*aLayerY = GetLayerPoint().y;
|
2004-08-20 18:09:19 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMUIEvent::GetIsChar(bool* aIsChar)
|
2004-08-20 18:09:19 +00:00
|
|
|
{
|
|
|
|
switch(mEvent->eventStructType)
|
|
|
|
{
|
|
|
|
case NS_KEY_EVENT:
|
|
|
|
*aIsChar = ((nsKeyEvent*)mEvent)->isChar;
|
|
|
|
return NS_OK;
|
|
|
|
case NS_TEXT_EVENT:
|
|
|
|
*aIsChar = ((nsTextEvent*)mEvent)->isChar;
|
|
|
|
return NS_OK;
|
|
|
|
default:
|
2011-10-17 14:59:28 +00:00
|
|
|
*aIsChar = false;
|
2004-08-20 18:09:19 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-10 23:37:47 +00:00
|
|
|
NS_METHOD
|
2007-11-12 12:53:06 +00:00
|
|
|
nsDOMUIEvent::DuplicatePrivateData()
|
|
|
|
{
|
2011-12-17 00:24:11 +00:00
|
|
|
mClientPoint = nsDOMEvent::GetClientCoords(mPresContext,
|
|
|
|
mEvent,
|
|
|
|
mEvent->refPoint,
|
|
|
|
mClientPoint);
|
2012-05-09 22:54:18 +00:00
|
|
|
mMovementPoint = GetMovementPoint();
|
2011-12-17 00:24:11 +00:00
|
|
|
mLayerPoint = GetLayerPoint();
|
|
|
|
mPagePoint = nsDOMEvent::GetPageCoords(mPresContext,
|
|
|
|
mEvent,
|
|
|
|
mEvent->refPoint,
|
|
|
|
mClientPoint);
|
|
|
|
// GetScreenPoint converts mEvent->refPoint to right coordinates.
|
|
|
|
nsIntPoint screenPoint = nsDOMEvent::GetScreenCoords(mPresContext,
|
|
|
|
mEvent,
|
|
|
|
mEvent->refPoint);
|
2007-11-12 12:53:06 +00:00
|
|
|
nsresult rv = nsDOMEvent::DuplicatePrivateData();
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
mEvent->refPoint = screenPoint;
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2012-06-10 23:37:47 +00:00
|
|
|
void
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMUIEvent::Serialize(IPC::Message* aMsg, bool aSerializeInterfaceType)
|
2009-11-17 14:22:23 +00:00
|
|
|
{
|
|
|
|
if (aSerializeInterfaceType) {
|
|
|
|
IPC::WriteParam(aMsg, NS_LITERAL_STRING("uievent"));
|
|
|
|
}
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
nsDOMEvent::Serialize(aMsg, false);
|
2009-11-17 14:22:23 +00:00
|
|
|
|
|
|
|
PRInt32 detail = 0;
|
|
|
|
GetDetail(&detail);
|
|
|
|
IPC::WriteParam(aMsg, detail);
|
|
|
|
}
|
|
|
|
|
2012-06-10 23:37:47 +00:00
|
|
|
bool
|
2009-11-17 14:22:23 +00:00
|
|
|
nsDOMUIEvent::Deserialize(const IPC::Message* aMsg, void** aIter)
|
|
|
|
{
|
2011-10-17 14:59:28 +00:00
|
|
|
NS_ENSURE_TRUE(nsDOMEvent::Deserialize(aMsg, aIter), false);
|
|
|
|
NS_ENSURE_TRUE(IPC::ReadParam(aMsg, aIter, &mDetail), false);
|
|
|
|
return true;
|
2009-11-17 14:22:23 +00:00
|
|
|
}
|
|
|
|
|
2012-04-25 03:00:01 +00:00
|
|
|
// XXX Following struct and array are used only in
|
|
|
|
// nsDOMUIEvent::ComputeModifierState(), but if we define them in it,
|
|
|
|
// we fail to build on Mac at calling mozilla::ArrayLength().
|
|
|
|
struct nsModifierPair
|
|
|
|
{
|
|
|
|
mozilla::widget::Modifier modifier;
|
|
|
|
const char* name;
|
|
|
|
};
|
|
|
|
static const nsModifierPair kPairs[] = {
|
|
|
|
{ widget::MODIFIER_ALT, NS_DOM_KEYNAME_ALT },
|
|
|
|
{ widget::MODIFIER_ALTGRAPH, NS_DOM_KEYNAME_ALTGRAPH },
|
|
|
|
{ widget::MODIFIER_CAPSLOCK, NS_DOM_KEYNAME_CAPSLOCK },
|
|
|
|
{ widget::MODIFIER_CONTROL, NS_DOM_KEYNAME_CONTROL },
|
|
|
|
{ widget::MODIFIER_FN, NS_DOM_KEYNAME_FN },
|
|
|
|
{ widget::MODIFIER_META, NS_DOM_KEYNAME_META },
|
|
|
|
{ widget::MODIFIER_NUMLOCK, NS_DOM_KEYNAME_NUMLOCK },
|
|
|
|
{ widget::MODIFIER_SCROLL, NS_DOM_KEYNAME_SCROLL },
|
|
|
|
{ widget::MODIFIER_SHIFT, NS_DOM_KEYNAME_SHIFT },
|
|
|
|
{ widget::MODIFIER_SYMBOLLOCK, NS_DOM_KEYNAME_SYMBOLLOCK },
|
|
|
|
{ widget::MODIFIER_WIN, NS_DOM_KEYNAME_WIN }
|
|
|
|
};
|
|
|
|
|
|
|
|
/* static */
|
|
|
|
mozilla::widget::Modifiers
|
|
|
|
nsDOMUIEvent::ComputeModifierState(const nsAString& aModifiersList)
|
|
|
|
{
|
|
|
|
if (aModifiersList.IsEmpty()) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Be careful about the performance. If aModifiersList is too long,
|
|
|
|
// parsing it needs too long time.
|
|
|
|
// XXX Should we abort if aModifiersList is too long?
|
|
|
|
|
|
|
|
Modifiers modifiers = 0;
|
|
|
|
|
|
|
|
nsAString::const_iterator listStart, listEnd;
|
|
|
|
aModifiersList.BeginReading(listStart);
|
|
|
|
aModifiersList.EndReading(listEnd);
|
|
|
|
|
|
|
|
for (PRUint32 i = 0; i < mozilla::ArrayLength(kPairs); i++) {
|
|
|
|
nsAString::const_iterator start(listStart), end(listEnd);
|
|
|
|
if (!FindInReadable(NS_ConvertASCIItoUTF16(kPairs[i].name), start, end)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((start != listStart && !NS_IsAsciiWhitespace(*(--start))) ||
|
|
|
|
(end != listEnd && !NS_IsAsciiWhitespace(*(end)))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
modifiers |= kPairs[i].modifier;
|
|
|
|
}
|
|
|
|
|
|
|
|
return modifiers;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
nsDOMUIEvent::GetModifierStateInternal(const nsAString& aKey)
|
|
|
|
{
|
2012-04-25 03:00:02 +00:00
|
|
|
nsInputEvent* inputEvent = static_cast<nsInputEvent*>(mEvent);
|
2012-04-25 03:00:01 +00:00
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_SHIFT)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsShift();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_CONTROL)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsControl();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_META)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsMeta();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_ALT)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsAlt();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_ALTGRAPH)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsAltGraph();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_WIN)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsWin();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_CAPSLOCK)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsCapsLocked();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_NUMLOCK)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsNumLocked();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_FN)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsFn();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_SCROLL)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsScrollLocked();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
if (aKey.EqualsLiteral(NS_DOM_KEYNAME_SYMBOLLOCK)) {
|
2012-04-25 03:00:02 +00:00
|
|
|
return inputEvent->IsSymbolLocked();
|
2012-04-25 03:00:01 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-20 18:09:19 +00:00
|
|
|
nsresult NS_NewDOMUIEvent(nsIDOMEvent** aInstancePtrResult,
|
|
|
|
nsPresContext* aPresContext,
|
|
|
|
nsGUIEvent *aEvent)
|
|
|
|
{
|
|
|
|
nsDOMUIEvent* it = new nsDOMUIEvent(aPresContext, aEvent);
|
|
|
|
return CallQueryInterface(it, aInstancePtrResult);
|
|
|
|
}
|