2004-06-20 16:42:13 +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-06-20 16:42:13 +00:00
|
|
|
|
2014-02-12 04:41:57 +00:00
|
|
|
#include "nsDOMWindowUtils.h"
|
|
|
|
|
|
|
|
#include "mozilla/layers/CompositorChild.h"
|
2013-11-27 15:19:34 +00:00
|
|
|
#include "mozilla/layers/LayerTransactionChild.h"
|
2004-07-31 23:15:21 +00:00
|
|
|
#include "nsPresContext.h"
|
2011-10-03 19:11:31 +00:00
|
|
|
#include "nsDOMClassInfoID.h"
|
2012-07-27 14:03:27 +00:00
|
|
|
#include "nsError.h"
|
2012-08-04 07:44:00 +00:00
|
|
|
#include "nsIDOMEvent.h"
|
2010-03-19 05:02:53 +00:00
|
|
|
#include "nsQueryContentEventResult.h"
|
2013-09-12 15:19:00 +00:00
|
|
|
#include "CompositionStringSynthesizer.h"
|
2004-06-20 16:42:13 +00:00
|
|
|
#include "nsGlobalWindow.h"
|
2004-11-18 20:50:16 +00:00
|
|
|
#include "nsIDocument.h"
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 18:00:39 +00:00
|
|
|
#include "nsFocusManager.h"
|
2010-09-17 18:56:53 +00:00
|
|
|
#include "nsEventStateManager.h"
|
2011-03-15 23:20:19 +00:00
|
|
|
#include "nsFrameManager.h"
|
2011-04-12 06:18:43 +00:00
|
|
|
#include "nsRefreshDriver.h"
|
2013-04-05 08:49:00 +00:00
|
|
|
#include "mozilla/dom/Touch.h"
|
2013-08-15 18:17:48 +00:00
|
|
|
#include "nsIObjectLoadingContent.h"
|
2012-09-10 21:02:23 +00:00
|
|
|
#include "nsFrame.h"
|
2013-08-15 18:17:48 +00:00
|
|
|
#include "mozilla/layers/ShadowLayers.h"
|
2004-06-20 16:42:13 +00:00
|
|
|
|
2009-09-03 03:57:46 +00:00
|
|
|
#include "nsIScrollableFrame.h"
|
2009-03-30 12:19:06 +00:00
|
|
|
|
2005-10-21 22:30:36 +00:00
|
|
|
#include "nsContentUtils.h"
|
|
|
|
|
|
|
|
#include "nsIFrame.h"
|
2007-02-26 21:14:19 +00:00
|
|
|
#include "nsIWidget.h"
|
2012-03-22 14:42:42 +00:00
|
|
|
#include "nsCharsetSource.h"
|
2007-11-06 21:47:35 +00:00
|
|
|
#include "nsJSEnvironment.h"
|
2011-12-16 21:11:08 +00:00
|
|
|
#include "nsJSUtils.h"
|
2005-10-21 22:30:36 +00:00
|
|
|
|
2013-09-25 11:21:20 +00:00
|
|
|
#include "mozilla/MiscEvents.h"
|
2013-09-25 11:21:18 +00:00
|
|
|
#include "mozilla/MouseEvents.h"
|
2013-09-25 11:21:19 +00:00
|
|
|
#include "mozilla/TextEvents.h"
|
2013-09-25 11:21:16 +00:00
|
|
|
#include "mozilla/TouchEvents.h"
|
|
|
|
|
2013-01-05 03:12:24 +00:00
|
|
|
#include "nsViewManager.h"
|
2008-08-27 21:24:03 +00:00
|
|
|
|
2008-12-03 01:34:07 +00:00
|
|
|
#include "nsIDOMHTMLCanvasElement.h"
|
|
|
|
#include "gfxImageSurface.h"
|
2010-02-24 19:04:32 +00:00
|
|
|
#include "nsLayoutUtils.h"
|
2010-04-03 01:58:25 +00:00
|
|
|
#include "nsComputedDOMStyle.h"
|
2010-08-27 23:15:07 +00:00
|
|
|
#include "nsIPresShell.h"
|
2010-10-23 23:31:55 +00:00
|
|
|
#include "nsStyleAnimation.h"
|
|
|
|
#include "nsCSSProps.h"
|
2011-09-27 00:25:41 +00:00
|
|
|
#include "nsDOMFile.h"
|
2012-03-28 15:53:56 +00:00
|
|
|
#include "nsTArrayHelpers.h"
|
2012-05-05 13:28:06 +00:00
|
|
|
#include "nsIDocShell.h"
|
|
|
|
#include "nsIContentViewer.h"
|
|
|
|
#include "nsIMarkupDocumentViewer.h"
|
2013-09-20 10:21:03 +00:00
|
|
|
#include "mozilla/dom/DOMRect.h"
|
2013-01-15 12:22:03 +00:00
|
|
|
#include <algorithm>
|
2008-12-03 01:34:07 +00:00
|
|
|
|
2012-06-28 00:15:32 +00:00
|
|
|
#if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK)
|
2008-06-04 00:00:37 +00:00
|
|
|
#include <gdk/gdk.h>
|
2006-03-24 23:30:24 +00:00
|
|
|
#include <gdk/gdkx.h>
|
|
|
|
#endif
|
|
|
|
|
2010-09-03 18:01:05 +00:00
|
|
|
#include "Layers.h"
|
2013-08-11 23:15:10 +00:00
|
|
|
#include "mozilla/layers/ShadowLayers.h"
|
2010-09-03 18:01:05 +00:00
|
|
|
|
2011-03-28 16:51:56 +00:00
|
|
|
#include "mozilla/dom/Element.h"
|
2014-02-24 20:56:13 +00:00
|
|
|
#include "mozilla/dom/file/FileHandle.h"
|
|
|
|
#include "mozilla/dom/FileHandleBinding.h"
|
2013-09-11 04:18:36 +00:00
|
|
|
#include "mozilla/dom/IDBFactoryBinding.h"
|
2011-12-16 07:34:24 +00:00
|
|
|
#include "mozilla/dom/indexedDB/IndexedDatabaseManager.h"
|
2013-09-11 04:18:36 +00:00
|
|
|
#include "mozilla/dom/quota/PersistenceType.h"
|
2013-03-26 11:13:17 +00:00
|
|
|
#include "mozilla/dom/quota/QuotaManager.h"
|
2012-06-03 16:33:52 +00:00
|
|
|
#include "nsDOMBlobBuilder.h"
|
2012-09-04 08:39:28 +00:00
|
|
|
#include "nsPrintfCString.h"
|
2012-12-17 21:24:41 +00:00
|
|
|
#include "nsViewportInfo.h"
|
2013-01-03 15:17:36 +00:00
|
|
|
#include "nsIFormControl.h"
|
2013-05-07 16:34:20 +00:00
|
|
|
#include "nsIScriptError.h"
|
2013-05-23 01:35:21 +00:00
|
|
|
#include "nsIAppShell.h"
|
|
|
|
#include "nsWidgetsCID.h"
|
2013-05-30 00:38:27 +00:00
|
|
|
#include "FrameLayerBuilder.h"
|
|
|
|
#include "nsDisplayList.h"
|
|
|
|
#include "nsROCSSPrimitiveValue.h"
|
2013-08-15 18:17:48 +00:00
|
|
|
#include "nsIBaseWindow.h"
|
|
|
|
#include "nsIDocShellTreeOwner.h"
|
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
2013-09-10 20:56:05 +00:00
|
|
|
#include "GeckoProfiler.h"
|
2013-11-27 07:32:19 +00:00
|
|
|
#include "mozilla/Preferences.h"
|
2011-03-28 16:51:56 +00:00
|
|
|
|
2013-05-27 23:47:45 +00:00
|
|
|
#ifdef XP_WIN
|
|
|
|
#undef GetClassName
|
|
|
|
#endif
|
|
|
|
|
2012-04-25 03:00:02 +00:00
|
|
|
using namespace mozilla;
|
2011-03-28 16:51:56 +00:00
|
|
|
using namespace mozilla::dom;
|
2010-09-03 18:01:05 +00:00
|
|
|
using namespace mozilla::layers;
|
2011-11-27 11:51:52 +00:00
|
|
|
using namespace mozilla::widget;
|
2013-12-11 21:05:27 +00:00
|
|
|
using namespace mozilla::gfx;
|
2010-09-03 18:01:05 +00:00
|
|
|
|
2013-08-15 18:17:48 +00:00
|
|
|
class gfxContext;
|
|
|
|
|
2013-05-23 01:35:21 +00:00
|
|
|
static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
|
|
|
|
|
2010-01-12 13:08:43 +00:00
|
|
|
DOMCI_DATA(WindowUtils, nsDOMWindowUtils)
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN(nsDOMWindowUtils)
|
2004-06-20 16:42:13 +00:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMWindowUtils)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMWindowUtils)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
2005-10-21 22:30:36 +00:00
|
|
|
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(WindowUtils)
|
2004-06-20 16:42:13 +00:00
|
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
NS_IMPL_ADDREF(nsDOMWindowUtils)
|
|
|
|
NS_IMPL_RELEASE(nsDOMWindowUtils)
|
2004-06-20 16:42:13 +00:00
|
|
|
|
2004-12-10 19:48:22 +00:00
|
|
|
nsDOMWindowUtils::nsDOMWindowUtils(nsGlobalWindow *aWindow)
|
|
|
|
{
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsISupports> supports = do_QueryObject(aWindow);
|
|
|
|
mWindow = do_GetWeakReference(supports);
|
|
|
|
NS_ASSERTION(aWindow->IsOuterWindow(), "How did that happen?");
|
2004-06-20 20:37:16 +00:00
|
|
|
}
|
2004-06-20 16:42:13 +00:00
|
|
|
|
2004-12-10 19:48:22 +00:00
|
|
|
nsDOMWindowUtils::~nsDOMWindowUtils()
|
|
|
|
{
|
2004-06-20 20:37:16 +00:00
|
|
|
}
|
2004-06-20 16:42:13 +00:00
|
|
|
|
2010-09-03 20:10:45 +00:00
|
|
|
nsIPresShell*
|
|
|
|
nsDOMWindowUtils::GetPresShell()
|
|
|
|
{
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
if (!window)
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2010-09-03 20:10:45 +00:00
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2010-09-03 20:10:45 +00:00
|
|
|
if (!docShell)
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2010-09-03 20:10:45 +00:00
|
|
|
|
2012-12-29 01:56:42 +00:00
|
|
|
return docShell->GetPresShell();
|
2010-09-03 20:10:45 +00:00
|
|
|
}
|
|
|
|
|
2009-01-06 01:15:13 +00:00
|
|
|
nsPresContext*
|
|
|
|
nsDOMWindowUtils::GetPresContext()
|
|
|
|
{
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
if (!window)
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2012-04-02 02:23:51 +00:00
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2009-01-06 01:15:13 +00:00
|
|
|
if (!docShell)
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2010-03-25 13:17:11 +00:00
|
|
|
nsRefPtr<nsPresContext> presContext;
|
2009-01-06 01:15:13 +00:00
|
|
|
docShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
return presContext;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsIDocument*
|
|
|
|
nsDOMWindowUtils::GetDocument()
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
if (!window) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return window->GetExtantDoc();
|
|
|
|
}
|
|
|
|
|
2014-03-21 21:59:57 +00:00
|
|
|
LayerTransactionChild*
|
|
|
|
nsDOMWindowUtils::GetLayerTransaction()
|
|
|
|
{
|
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
LayerManager* manager = widget->GetLayerManager();
|
|
|
|
if (!manager)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
ShadowLayerForwarder* forwarder = manager->AsShadowForwarder();
|
|
|
|
return forwarder && forwarder->HasShadowManager() ?
|
|
|
|
forwarder->GetShadowManager() :
|
|
|
|
nullptr;
|
|
|
|
}
|
|
|
|
|
2004-06-20 16:42:13 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetImageAnimationMode(uint16_t *aMode)
|
2004-12-10 19:48:22 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2004-06-20 16:42:13 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aMode);
|
|
|
|
*aMode = 0;
|
2009-01-06 01:15:13 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
|
|
|
*aMode = presContext->ImageAnimationMode();
|
|
|
|
return NS_OK;
|
2004-06-20 16:42:13 +00:00
|
|
|
}
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::SetImageAnimationMode(uint16_t aMode)
|
2004-12-10 19:48:22 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2009-01-06 01:15:13 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
|
|
|
presContext->SetImageAnimationMode(aMode);
|
|
|
|
return NS_OK;
|
2004-06-20 16:42:13 +00:00
|
|
|
}
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
2004-11-18 20:50:16 +00:00
|
|
|
|
2007-08-11 18:37:16 +00:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::GetDocCharsetIsForced(bool *aIsForced)
|
2007-08-11 18:37:16 +00:00
|
|
|
{
|
2011-10-17 14:59:28 +00:00
|
|
|
*aIsForced = false;
|
2007-08-11 18:37:16 +00:00
|
|
|
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2007-08-11 18:37:16 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2007-08-11 18:37:16 +00:00
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsIDocument* doc = GetDocument();
|
|
|
|
*aIsForced = doc &&
|
|
|
|
doc->GetDocumentCharacterSetSource() >= kCharsetFromParentForced;
|
2007-08-11 18:37:16 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-11-18 20:50:16 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetDocumentMetadata(const nsAString& aName,
|
|
|
|
nsAString& aValue)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2005-10-21 22:30:36 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2005-10-21 22:30:36 +00:00
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsIDocument* doc = GetDocument();
|
|
|
|
if (doc) {
|
|
|
|
nsCOMPtr<nsIAtom> name = do_GetAtom(aName);
|
|
|
|
doc->GetHeaderData(name, aValue);
|
|
|
|
return NS_OK;
|
2004-11-18 20:50:16 +00:00
|
|
|
}
|
2013-04-24 04:22:37 +00:00
|
|
|
|
2004-11-18 20:50:16 +00:00
|
|
|
aValue.Truncate();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2005-10-21 22:30:36 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::Redraw(uint32_t aCount, uint32_t *aDurationOut)
|
2005-10-21 22:30:36 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2008-06-04 00:00:37 +00:00
|
|
|
if (aCount == 0)
|
|
|
|
aCount = 1;
|
|
|
|
|
2010-09-03 20:10:45 +00:00
|
|
|
if (nsIPresShell* presShell = GetPresShell()) {
|
|
|
|
nsIFrame *rootFrame = presShell->GetRootFrame();
|
2005-10-21 22:30:36 +00:00
|
|
|
|
2010-09-03 20:10:45 +00:00
|
|
|
if (rootFrame) {
|
|
|
|
PRIntervalTime iStart = PR_IntervalNow();
|
2008-06-04 00:00:37 +00:00
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t i = 0; i < aCount; i++)
|
2012-08-29 05:39:31 +00:00
|
|
|
rootFrame->InvalidateFrame();
|
2008-06-04 00:00:37 +00:00
|
|
|
|
2012-06-28 00:15:32 +00:00
|
|
|
#if defined(MOZ_X11) && defined(MOZ_WIDGET_GTK)
|
|
|
|
XSync(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), False);
|
2006-03-24 23:30:24 +00:00
|
|
|
#endif
|
2008-06-04 00:00:37 +00:00
|
|
|
|
2010-09-03 20:10:45 +00:00
|
|
|
*aDurationOut = PR_IntervalToMilliseconds(PR_IntervalNow() - iStart);
|
2008-06-04 00:00:37 +00:00
|
|
|
|
2010-09-03 20:10:45 +00:00
|
|
|
return NS_OK;
|
2005-10-21 22:30:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2007-02-26 21:14:19 +00:00
|
|
|
|
2010-09-03 20:10:45 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetCSSViewport(float aWidthPx, float aHeightPx)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-09-03 20:10:45 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(aWidthPx >= 0.0 && aHeightPx >= 0.0)) {
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nscoord width = nsPresContext::CSSPixelsToAppUnits(aWidthPx);
|
|
|
|
nscoord height = nsPresContext::CSSPixelsToAppUnits(aHeightPx);
|
|
|
|
|
2010-09-24 22:41:31 +00:00
|
|
|
presShell->ResizeReflowOverride(width, height);
|
2010-09-03 20:10:45 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-08-22 20:17:20 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetViewportInfo(uint32_t aDisplayWidth,
|
|
|
|
uint32_t aDisplayHeight,
|
|
|
|
double *aDefaultZoom, bool *aAllowZoom,
|
|
|
|
double *aMinZoom, double *aMaxZoom,
|
|
|
|
uint32_t *aWidth, uint32_t *aHeight,
|
|
|
|
bool *aAutoSize)
|
|
|
|
{
|
2014-03-08 09:22:28 +00:00
|
|
|
nsIDocument* doc = GetDocument();
|
2012-08-22 20:17:20 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
2013-09-03 19:12:24 +00:00
|
|
|
nsViewportInfo info = nsContentUtils::GetViewportInfo(doc, ScreenIntSize(aDisplayWidth, aDisplayHeight));
|
2013-09-03 19:12:23 +00:00
|
|
|
*aDefaultZoom = info.GetDefaultZoom().scale;
|
2012-12-17 21:24:41 +00:00
|
|
|
*aAllowZoom = info.IsZoomAllowed();
|
2013-09-03 19:12:23 +00:00
|
|
|
*aMinZoom = info.GetMinZoom().scale;
|
|
|
|
*aMaxZoom = info.GetMaxZoom().scale;
|
2013-09-03 19:12:24 +00:00
|
|
|
*aWidth = info.GetSize().width;
|
|
|
|
*aHeight = info.GetSize().height;
|
2012-12-17 21:24:41 +00:00
|
|
|
*aAutoSize = info.IsAutoSizeEnabled();
|
2012-08-22 20:17:20 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-03-15 23:20:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetDisplayPortForElement(float aXPx, float aYPx,
|
|
|
|
float aWidthPx, float aHeightPx,
|
2014-03-08 09:25:15 +00:00
|
|
|
nsIDOMElement* aElement,
|
|
|
|
uint32_t aPriority)
|
2010-09-03 20:10:46 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-09-03 20:10:46 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
2012-05-05 13:25:26 +00:00
|
|
|
}
|
2010-09-03 20:10:46 +00:00
|
|
|
|
2011-03-15 23:20:19 +00:00
|
|
|
if (!aElement) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
|
|
|
|
if (!content) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2012-04-16 13:48:04 +00:00
|
|
|
if (content->GetCurrentDoc() != presShell->GetDocument()) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:25:15 +00:00
|
|
|
DisplayPortPropertyData* currentData =
|
|
|
|
static_cast<DisplayPortPropertyData*>(content->GetProperty(nsGkAtoms::DisplayPort));
|
|
|
|
if (currentData && currentData->mPriority > aPriority) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-03-27 01:46:24 +00:00
|
|
|
nsRect displayport(nsPresContext::CSSPixelsToAppUnits(aXPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aYPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aWidthPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aHeightPx));
|
|
|
|
|
2014-03-08 09:25:15 +00:00
|
|
|
content->SetProperty(nsGkAtoms::DisplayPort,
|
|
|
|
new DisplayPortPropertyData(displayport, aPriority),
|
2014-03-25 13:25:47 +00:00
|
|
|
nsINode::DeleteProperty<DisplayPortPropertyData>);
|
2011-03-15 23:20:19 +00:00
|
|
|
|
|
|
|
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
|
2014-03-27 01:46:24 +00:00
|
|
|
if (rootScrollFrame && content == rootScrollFrame->GetContent()) {
|
|
|
|
// We are setting a root displayport for a document.
|
|
|
|
// The pres shell needs a special flag set.
|
|
|
|
presShell->SetIgnoreViewportScrolling(true);
|
2011-03-15 23:20:19 +00:00
|
|
|
}
|
|
|
|
|
2012-05-05 13:25:26 +00:00
|
|
|
nsIFrame* rootFrame = presShell->FrameManager()->GetRootFrame();
|
|
|
|
if (rootFrame) {
|
2012-12-17 00:20:02 +00:00
|
|
|
rootFrame->SchedulePaint();
|
2012-05-05 13:25:26 +00:00
|
|
|
|
|
|
|
// If we are hiding something that is a display root then send empty paint
|
|
|
|
// transaction in order to release retained layers because it won't get
|
|
|
|
// any more paint requests when it is hidden.
|
|
|
|
if (displayport.IsEmpty() &&
|
|
|
|
rootFrame == nsLayoutUtils::GetDisplayRootFrame(rootFrame)) {
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (widget) {
|
|
|
|
bool isRetainingManager;
|
|
|
|
LayerManager* manager = widget->GetLayerManager(&isRetainingManager);
|
|
|
|
if (isRetainingManager) {
|
|
|
|
manager->BeginTransaction();
|
2012-07-30 14:20:58 +00:00
|
|
|
nsLayoutUtils::PaintFrame(nullptr, rootFrame, nsRegion(), NS_RGB(255, 255, 255),
|
2012-05-05 13:25:26 +00:00
|
|
|
nsLayoutUtils::PAINT_WIDGET_LAYERS |
|
|
|
|
nsLayoutUtils::PAINT_EXISTING_TRANSACTION);
|
2011-10-18 19:28:39 +00:00
|
|
|
}
|
|
|
|
}
|
2011-03-15 23:20:19 +00:00
|
|
|
}
|
|
|
|
}
|
2010-09-03 20:10:46 +00:00
|
|
|
|
2012-11-21 22:34:18 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-03-27 01:46:23 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetDisplayPortMarginsForElement(float aLeftMargin,
|
|
|
|
float aTopMargin,
|
|
|
|
float aRightMargin,
|
|
|
|
float aBottomMargin,
|
|
|
|
uint32_t aAlignment,
|
|
|
|
nsIDOMElement* aElement,
|
|
|
|
uint32_t aPriority)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aElement) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
|
|
|
|
if (!content) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (content->GetCurrentDoc() != presShell->GetDocument()) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
DisplayPortMarginsPropertyData* currentData =
|
|
|
|
static_cast<DisplayPortMarginsPropertyData*>(content->GetProperty(nsGkAtoms::DisplayPortMargins));
|
|
|
|
if (currentData && currentData->mPriority > aPriority) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-03-27 01:46:24 +00:00
|
|
|
// Note order change of arguments between our function signature and
|
|
|
|
// LayerMargin constructor.
|
|
|
|
LayerMargin displayportMargins(aTopMargin,
|
|
|
|
aRightMargin,
|
|
|
|
aBottomMargin,
|
|
|
|
aLeftMargin);
|
|
|
|
|
2014-03-27 01:46:23 +00:00
|
|
|
content->SetProperty(nsGkAtoms::DisplayPortMargins,
|
|
|
|
new DisplayPortMarginsPropertyData(displayportMargins, aAlignment, aPriority),
|
|
|
|
nsINode::DeleteProperty<DisplayPortMarginsPropertyData>);
|
|
|
|
|
|
|
|
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
|
2014-03-27 01:46:24 +00:00
|
|
|
if (rootScrollFrame && content == rootScrollFrame->GetContent()) {
|
|
|
|
// We are setting a root displayport for a document.
|
|
|
|
// The pres shell needs a special flag set.
|
|
|
|
presShell->SetIgnoreViewportScrolling(true);
|
2014-03-27 01:46:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsIFrame* rootFrame = presShell->FrameManager()->GetRootFrame();
|
|
|
|
if (rootFrame) {
|
|
|
|
rootFrame->SchedulePaint();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetDisplayPortBaseForElement(int32_t aX,
|
|
|
|
int32_t aY,
|
|
|
|
int32_t aWidth,
|
|
|
|
int32_t aHeight,
|
|
|
|
nsIDOMElement* aElement)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aElement) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
|
|
|
|
if (!content) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (content->GetCurrentDoc() != presShell->GetDocument()) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
content->SetProperty(nsGkAtoms::DisplayPortBase, new nsRect(aX, aY, aWidth, aHeight),
|
|
|
|
nsINode::DeleteProperty<nsRect>);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-11-21 22:34:18 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetCriticalDisplayPortForElement(float aXPx, float aYPx,
|
|
|
|
float aWidthPx, float aHeightPx,
|
|
|
|
nsIDOMElement* aElement)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aElement) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
|
|
|
|
if (!content) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (content->GetCurrentDoc() != presShell->GetDocument()) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRect displayport;
|
|
|
|
if (!nsLayoutUtils::GetDisplayPort(content, &displayport)) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRect criticalDisplayport(nsPresContext::CSSPixelsToAppUnits(aXPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aYPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aWidthPx),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aHeightPx));
|
|
|
|
content->SetProperty(nsGkAtoms::CriticalDisplayPort, new nsRect(criticalDisplayport),
|
2014-03-25 13:25:47 +00:00
|
|
|
nsINode::DeleteProperty<nsRect>);
|
2012-11-21 22:34:18 +00:00
|
|
|
|
|
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
|
|
|
if (rootFrame) {
|
|
|
|
rootFrame->InvalidateFrame();
|
|
|
|
}
|
|
|
|
|
2010-09-03 20:10:46 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-09-03 20:10:46 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetResolution(float aXResolution, float aYResolution)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-09-03 20:10:46 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
return presShell ? presShell->SetResolution(aXResolution, aYResolution)
|
|
|
|
: NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2012-10-26 21:09:38 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetResolution(float* aXResolution, float* aYResolution)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
|
|
|
|
if (presShell) {
|
|
|
|
*aXResolution = presShell->GetXResolution();
|
|
|
|
*aYResolution = presShell->GetYResolution();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2012-03-12 15:50:11 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetIsFirstPaint(bool aIsFirstPaint)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-03-12 15:50:11 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (presShell) {
|
|
|
|
presShell->SetIsFirstPaint(aIsFirstPaint);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsFirstPaint(bool *aIsFirstPaint)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-03-12 15:50:11 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (presShell) {
|
|
|
|
*aIsFirstPaint = presShell->GetIsFirstPaint();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2013-05-24 01:43:36 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetPresShellId(uint32_t *aPresShellId)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (presShell) {
|
|
|
|
*aPresShellId = presShell->GetPresShellId();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2012-04-25 03:00:02 +00:00
|
|
|
/* static */
|
2013-09-14 02:39:41 +00:00
|
|
|
mozilla::Modifiers
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetWidgetModifiers(int32_t aModifiers)
|
2012-04-25 03:00:02 +00:00
|
|
|
{
|
2013-09-14 02:39:41 +00:00
|
|
|
Modifiers result = 0;
|
2012-04-25 03:00:02 +00:00
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_SHIFT) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_SHIFT;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_CONTROL) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_CONTROL;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_ALT) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_ALT;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_META) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_META;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_ALTGRAPH) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_ALTGRAPH;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_CAPSLOCK) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_CAPSLOCK;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_FN) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_FN;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_NUMLOCK) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_NUMLOCK;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
2012-07-06 00:42:05 +00:00
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_SCROLLLOCK) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_SCROLLLOCK;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_SYMBOLLOCK) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_SYMBOLLOCK;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
2012-07-06 00:42:05 +00:00
|
|
|
if (aModifiers & nsIDOMWindowUtils::MODIFIER_OS) {
|
2013-09-14 02:39:41 +00:00
|
|
|
result |= mozilla::MODIFIER_OS;
|
2012-04-25 03:00:02 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-02-26 21:14:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendMouseEvent(const nsAString& aType,
|
2008-11-26 21:52:42 +00:00
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2012-08-14 14:27:39 +00:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
float aPressure,
|
2013-02-05 21:40:34 +00:00
|
|
|
unsigned short aInputSourceArg,
|
2014-01-15 14:28:04 +00:00
|
|
|
bool aIsSynthesized,
|
|
|
|
uint8_t aOptionalArgCount,
|
2013-02-05 21:40:34 +00:00
|
|
|
bool *aPreventDefault)
|
2010-08-27 23:15:07 +00:00
|
|
|
{
|
|
|
|
return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
|
2012-08-25 16:04:14 +00:00
|
|
|
aIgnoreRootScrollFrame, aPressure,
|
2014-01-15 14:28:04 +00:00
|
|
|
aInputSourceArg, false, aPreventDefault,
|
|
|
|
aOptionalArgCount >= 4 ? aIsSynthesized : true);
|
2010-08-27 23:15:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendMouseEventToWindow(const nsAString& aType,
|
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2012-08-14 14:27:39 +00:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
float aPressure,
|
2014-01-15 14:28:04 +00:00
|
|
|
unsigned short aInputSourceArg,
|
|
|
|
bool aIsSynthesized,
|
|
|
|
uint8_t aOptionalArgCount)
|
2010-08-27 23:15:07 +00:00
|
|
|
{
|
2013-03-16 04:47:02 +00:00
|
|
|
PROFILER_LABEL("nsDOMWindowUtils", "SendMouseEventToWindow");
|
2010-08-27 23:15:07 +00:00
|
|
|
return SendMouseEventCommon(aType, aX, aY, aButton, aClickCount, aModifiers,
|
2012-08-25 16:04:14 +00:00
|
|
|
aIgnoreRootScrollFrame, aPressure,
|
2014-01-15 14:28:04 +00:00
|
|
|
aInputSourceArg, true, nullptr,
|
|
|
|
aOptionalArgCount >= 4 ? aIsSynthesized : true);
|
2010-08-27 23:15:07 +00:00
|
|
|
}
|
|
|
|
|
2013-08-02 07:05:16 +00:00
|
|
|
static LayoutDeviceIntPoint
|
|
|
|
ToWidgetPoint(const CSSPoint& aPoint, const nsPoint& aOffset,
|
2012-05-10 05:24:20 +00:00
|
|
|
nsPresContext* aPresContext)
|
|
|
|
{
|
2013-08-30 17:22:33 +00:00
|
|
|
return LayoutDeviceIntPoint::FromAppUnitsRounded(
|
2013-08-02 07:05:16 +00:00
|
|
|
CSSPoint::ToAppUnits(aPoint) + aOffset,
|
|
|
|
aPresContext->AppUnitsPerDevPixel());
|
2012-05-10 05:24:20 +00:00
|
|
|
}
|
|
|
|
|
2013-03-04 20:15:39 +00:00
|
|
|
static inline int16_t
|
|
|
|
GetButtonsFlagForButton(int32_t aButton)
|
|
|
|
{
|
|
|
|
switch (aButton) {
|
2013-10-02 06:38:27 +00:00
|
|
|
case WidgetMouseEvent::eLeftButton:
|
|
|
|
return WidgetMouseEvent::eLeftButtonFlag;
|
|
|
|
case WidgetMouseEvent::eMiddleButton:
|
|
|
|
return WidgetMouseEvent::eMiddleButtonFlag;
|
|
|
|
case WidgetMouseEvent::eRightButton:
|
|
|
|
return WidgetMouseEvent::eRightButtonFlag;
|
2013-03-04 20:15:39 +00:00
|
|
|
case 4:
|
2013-10-02 06:38:27 +00:00
|
|
|
return WidgetMouseEvent::e4thButtonFlag;
|
2013-03-04 20:15:39 +00:00
|
|
|
case 5:
|
2013-10-02 06:38:27 +00:00
|
|
|
return WidgetMouseEvent::e5thButtonFlag;
|
2013-03-04 20:15:39 +00:00
|
|
|
default:
|
|
|
|
NS_ERROR("Button not known.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-27 23:15:07 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendMouseEventCommon(const nsAString& aType,
|
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aIgnoreRootScrollFrame,
|
2012-08-14 14:27:39 +00:00
|
|
|
float aPressure,
|
|
|
|
unsigned short aInputSourceArg,
|
2013-02-05 21:40:34 +00:00
|
|
|
bool aToWindow,
|
2014-01-15 14:28:04 +00:00
|
|
|
bool *aPreventDefault,
|
|
|
|
bool aIsSynthesized)
|
2007-02-26 21:14:19 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2007-02-26 21:14:19 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2007-02-26 21:14:19 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
2008-11-26 21:52:42 +00:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2007-02-26 21:14:19 +00:00
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t msg;
|
2011-09-29 06:19:26 +00:00
|
|
|
bool contextMenuKey = false;
|
2007-02-26 21:14:19 +00:00
|
|
|
if (aType.EqualsLiteral("mousedown"))
|
|
|
|
msg = NS_MOUSE_BUTTON_DOWN;
|
|
|
|
else if (aType.EqualsLiteral("mouseup"))
|
|
|
|
msg = NS_MOUSE_BUTTON_UP;
|
|
|
|
else if (aType.EqualsLiteral("mousemove"))
|
|
|
|
msg = NS_MOUSE_MOVE;
|
|
|
|
else if (aType.EqualsLiteral("mouseover"))
|
|
|
|
msg = NS_MOUSE_ENTER;
|
|
|
|
else if (aType.EqualsLiteral("mouseout"))
|
|
|
|
msg = NS_MOUSE_EXIT;
|
2007-09-18 07:25:49 +00:00
|
|
|
else if (aType.EqualsLiteral("contextmenu")) {
|
2007-02-26 21:14:19 +00:00
|
|
|
msg = NS_CONTEXTMENU;
|
2007-09-18 07:25:49 +00:00
|
|
|
contextMenuKey = (aButton == 0);
|
2013-02-05 21:40:34 +00:00
|
|
|
} else if (aType.EqualsLiteral("MozMouseHittest"))
|
|
|
|
msg = NS_MOUSE_MOZHITTEST;
|
|
|
|
else
|
2007-02-26 21:14:19 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-08-14 14:27:39 +00:00
|
|
|
if (aInputSourceArg == nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN) {
|
|
|
|
aInputSourceArg = nsIDOMMouseEvent::MOZ_SOURCE_MOUSE;
|
|
|
|
}
|
|
|
|
|
2013-10-02 06:38:27 +00:00
|
|
|
WidgetMouseEvent event(true, msg, widget, WidgetMouseEvent::eReal,
|
|
|
|
contextMenuKey ? WidgetMouseEvent::eContextMenuKey :
|
|
|
|
WidgetMouseEvent::eNormal);
|
2012-04-25 03:00:02 +00:00
|
|
|
event.modifiers = GetWidgetModifiers(aModifiers);
|
2007-02-26 21:14:19 +00:00
|
|
|
event.button = aButton;
|
2013-03-04 20:15:39 +00:00
|
|
|
event.buttons = GetButtonsFlagForButton(aButton);
|
2007-02-26 21:14:19 +00:00
|
|
|
event.widget = widget;
|
2012-08-14 14:27:39 +00:00
|
|
|
event.pressure = aPressure;
|
|
|
|
event.inputSource = aInputSourceArg;
|
2007-02-26 21:14:19 +00:00
|
|
|
event.clickCount = aClickCount;
|
|
|
|
event.time = PR_IntervalNow();
|
2014-01-15 14:28:04 +00:00
|
|
|
event.mFlags.mIsSynthesizedForTests = aIsSynthesized;
|
2008-11-26 21:52:42 +00:00
|
|
|
|
2010-07-19 02:23:48 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-08-02 07:05:16 +00:00
|
|
|
event.refPoint = ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
|
2008-11-28 19:53:33 +00:00
|
|
|
event.ignoreRootScrollFrame = aIgnoreRootScrollFrame;
|
2007-02-26 21:14:19 +00:00
|
|
|
|
|
|
|
nsEventStatus status;
|
2010-08-27 23:15:07 +00:00
|
|
|
if (aToWindow) {
|
2011-11-21 17:53:20 +00:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
|
2010-08-27 23:15:07 +00:00
|
|
|
if (!presShell)
|
|
|
|
return NS_ERROR_FAILURE;
|
2013-01-05 03:12:24 +00:00
|
|
|
nsViewManager* viewManager = presShell->GetViewManager();
|
2010-08-27 23:15:07 +00:00
|
|
|
if (!viewManager)
|
|
|
|
return NS_ERROR_FAILURE;
|
2013-01-03 13:23:11 +00:00
|
|
|
nsView* view = viewManager->GetRootView();
|
2011-03-30 02:24:54 +00:00
|
|
|
if (!view)
|
2010-08-27 23:15:07 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
status = nsEventStatus_eIgnore;
|
2011-11-21 17:53:20 +00:00
|
|
|
return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
|
2010-08-27 23:15:07 +00:00
|
|
|
}
|
2013-02-05 21:40:34 +00:00
|
|
|
nsresult rv = widget->DispatchEvent(&event, status);
|
|
|
|
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
|
|
|
|
|
|
|
|
return rv;
|
2007-02-26 21:14:19 +00:00
|
|
|
}
|
|
|
|
|
2014-02-11 14:16:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendPointerEvent(const nsAString& aType,
|
|
|
|
float aX,
|
|
|
|
float aY,
|
|
|
|
int32_t aButton,
|
|
|
|
int32_t aClickCount,
|
|
|
|
int32_t aModifiers,
|
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
float aPressure,
|
|
|
|
unsigned short aInputSourceArg,
|
|
|
|
int32_t aPointerId,
|
|
|
|
int32_t aWidth,
|
|
|
|
int32_t aHeight,
|
|
|
|
int32_t tiltX,
|
|
|
|
int32_t tiltY,
|
|
|
|
bool aIsPrimary,
|
|
|
|
bool aIsSynthesized,
|
|
|
|
uint8_t aOptionalArgCount,
|
|
|
|
bool* aPreventDefault)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t msg;
|
|
|
|
if (aType.EqualsLiteral("pointerdown")) {
|
|
|
|
msg = NS_POINTER_DOWN;
|
|
|
|
} else if (aType.EqualsLiteral("pointerup")) {
|
|
|
|
msg = NS_POINTER_UP;
|
|
|
|
} else if (aType.EqualsLiteral("pointermove")) {
|
|
|
|
msg = NS_POINTER_MOVE;
|
|
|
|
} else if (aType.EqualsLiteral("pointerover")) {
|
|
|
|
msg = NS_POINTER_OVER;
|
|
|
|
} else if (aType.EqualsLiteral("pointerout")) {
|
|
|
|
msg = NS_POINTER_OUT;
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aInputSourceArg == nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN) {
|
|
|
|
aInputSourceArg = nsIDOMMouseEvent::MOZ_SOURCE_MOUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
WidgetPointerEvent event(true, msg, widget);
|
|
|
|
event.modifiers = GetWidgetModifiers(aModifiers);
|
|
|
|
event.button = aButton;
|
|
|
|
event.buttons = GetButtonsFlagForButton(aButton);
|
|
|
|
event.widget = widget;
|
|
|
|
event.pressure = aPressure;
|
|
|
|
event.inputSource = aInputSourceArg;
|
|
|
|
event.pointerId = aPointerId;
|
|
|
|
event.width = aWidth;
|
|
|
|
event.height = aHeight;
|
|
|
|
event.tiltX = tiltX;
|
|
|
|
event.tiltY = tiltY;
|
|
|
|
event.isPrimary = aIsPrimary;
|
|
|
|
event.clickCount = aClickCount;
|
|
|
|
event.time = PR_IntervalNow();
|
|
|
|
event.mFlags.mIsSynthesizedForTests = aOptionalArgCount >= 10 ? aIsSynthesized : true;
|
|
|
|
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
event.refPoint = ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
|
|
|
|
event.ignoreRootScrollFrame = aIgnoreRootScrollFrame;
|
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
nsresult rv = widget->DispatchEvent(&event, status);
|
|
|
|
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2008-08-13 03:08:59 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-12 01:42:36 +00:00
|
|
|
nsDOMWindowUtils::SendWheelEvent(float aX,
|
|
|
|
float aY,
|
|
|
|
double aDeltaX,
|
|
|
|
double aDeltaY,
|
|
|
|
double aDeltaZ,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aDeltaMode,
|
|
|
|
int32_t aModifiers,
|
|
|
|
int32_t aLineOrPageDeltaX,
|
|
|
|
int32_t aLineOrPageDeltaY,
|
|
|
|
uint32_t aOptions)
|
2008-08-13 03:08:59 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2008-08-13 03:08:59 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2008-08-13 03:08:59 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
2008-11-26 21:52:42 +00:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2012-08-12 01:42:36 +00:00
|
|
|
if (!widget) {
|
2008-08-13 03:08:59 +00:00
|
|
|
return NS_ERROR_NULL_POINTER;
|
2012-08-12 01:42:36 +00:00
|
|
|
}
|
2008-08-13 03:08:59 +00:00
|
|
|
|
2013-10-16 09:37:36 +00:00
|
|
|
WidgetWheelEvent wheelEvent(true, NS_WHEEL_WHEEL, widget);
|
2012-08-12 01:42:36 +00:00
|
|
|
wheelEvent.modifiers = GetWidgetModifiers(aModifiers);
|
|
|
|
wheelEvent.deltaX = aDeltaX;
|
|
|
|
wheelEvent.deltaY = aDeltaY;
|
|
|
|
wheelEvent.deltaZ = aDeltaZ;
|
|
|
|
wheelEvent.deltaMode = aDeltaMode;
|
|
|
|
wheelEvent.isMomentum =
|
|
|
|
(aOptions & WHEEL_EVENT_CAUSED_BY_MOMENTUM) != 0;
|
|
|
|
wheelEvent.isPixelOnlyDevice =
|
|
|
|
(aOptions & WHEEL_EVENT_CAUSED_BY_PIXEL_ONLY_DEVICE) != 0;
|
|
|
|
NS_ENSURE_TRUE(
|
|
|
|
!wheelEvent.isPixelOnlyDevice ||
|
|
|
|
aDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL,
|
|
|
|
NS_ERROR_INVALID_ARG);
|
|
|
|
wheelEvent.customizedByUserPrefs =
|
|
|
|
(aOptions & WHEEL_EVENT_CUSTOMIZED_BY_USER_PREFS) != 0;
|
|
|
|
wheelEvent.lineOrPageDeltaX = aLineOrPageDeltaX;
|
|
|
|
wheelEvent.lineOrPageDeltaY = aLineOrPageDeltaY;
|
|
|
|
wheelEvent.widget = widget;
|
|
|
|
|
|
|
|
wheelEvent.time = PR_Now() / 1000;
|
2008-11-26 21:52:42 +00:00
|
|
|
|
2010-07-19 02:23:48 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
2012-08-12 01:42:36 +00:00
|
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
2010-07-19 02:23:48 +00:00
|
|
|
|
2013-08-02 07:05:16 +00:00
|
|
|
wheelEvent.refPoint = ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
|
2008-08-13 03:08:59 +00:00
|
|
|
|
|
|
|
nsEventStatus status;
|
2012-08-12 01:42:36 +00:00
|
|
|
nsresult rv = widget->DispatchEvent(&wheelEvent, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2012-09-04 08:39:28 +00:00
|
|
|
|
|
|
|
bool failedX = false;
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_ZERO) &&
|
|
|
|
wheelEvent.overflowDeltaX != 0) {
|
|
|
|
failedX = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_POSITIVE) &&
|
|
|
|
wheelEvent.overflowDeltaX <= 0) {
|
|
|
|
failedX = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_NEGATIVE) &&
|
|
|
|
wheelEvent.overflowDeltaX >= 0) {
|
|
|
|
failedX = true;
|
|
|
|
}
|
|
|
|
bool failedY = false;
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_ZERO) &&
|
|
|
|
wheelEvent.overflowDeltaY != 0) {
|
|
|
|
failedY = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_POSITIVE) &&
|
|
|
|
wheelEvent.overflowDeltaY <= 0) {
|
|
|
|
failedY = true;
|
|
|
|
}
|
|
|
|
if ((aOptions & WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_NEGATIVE) &&
|
|
|
|
wheelEvent.overflowDeltaY >= 0) {
|
|
|
|
failedY = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (failedX) {
|
|
|
|
nsPrintfCString debugMsg("SendWheelEvent(): unexpected overflowDeltaX: %f",
|
|
|
|
wheelEvent.overflowDeltaX);
|
|
|
|
NS_WARNING(debugMsg.get());
|
|
|
|
}
|
|
|
|
if (failedY) {
|
|
|
|
nsPrintfCString debugMsg("SendWheelEvent(): unexpected overflowDeltaY: %f",
|
|
|
|
wheelEvent.overflowDeltaY);
|
|
|
|
NS_WARNING(debugMsg.get());
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return (!failedX && !failedY) ? NS_OK : NS_ERROR_FAILURE;
|
2008-08-13 03:08:59 +00:00
|
|
|
}
|
|
|
|
|
2011-12-17 00:24:11 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendTouchEvent(const nsAString& aType,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t *aIdentifiers,
|
|
|
|
int32_t *aXs,
|
|
|
|
int32_t *aYs,
|
|
|
|
uint32_t *aRxs,
|
|
|
|
uint32_t *aRys,
|
2011-12-17 00:24:11 +00:00
|
|
|
float *aRotationAngles,
|
|
|
|
float *aForces,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aCount,
|
|
|
|
int32_t aModifiers,
|
2011-12-17 00:24:11 +00:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool *aPreventDefault)
|
2013-12-03 15:10:47 +00:00
|
|
|
{
|
|
|
|
return SendTouchEventCommon(aType, aIdentifiers, aXs, aYs, aRxs, aRys,
|
|
|
|
aRotationAngles, aForces, aCount, aModifiers,
|
|
|
|
aIgnoreRootScrollFrame, false, aPreventDefault);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendTouchEventToWindow(const nsAString& aType,
|
|
|
|
uint32_t* aIdentifiers,
|
|
|
|
int32_t* aXs,
|
|
|
|
int32_t* aYs,
|
|
|
|
uint32_t* aRxs,
|
|
|
|
uint32_t* aRys,
|
|
|
|
float* aRotationAngles,
|
|
|
|
float* aForces,
|
|
|
|
uint32_t aCount,
|
|
|
|
int32_t aModifiers,
|
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool* aPreventDefault)
|
|
|
|
{
|
|
|
|
return SendTouchEventCommon(aType, aIdentifiers, aXs, aYs, aRxs, aRys,
|
|
|
|
aRotationAngles, aForces, aCount, aModifiers,
|
|
|
|
aIgnoreRootScrollFrame, true, aPreventDefault);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendTouchEventCommon(const nsAString& aType,
|
|
|
|
uint32_t* aIdentifiers,
|
|
|
|
int32_t* aXs,
|
|
|
|
int32_t* aYs,
|
|
|
|
uint32_t* aRxs,
|
|
|
|
uint32_t* aRys,
|
|
|
|
float* aRotationAngles,
|
|
|
|
float* aForces,
|
|
|
|
uint32_t aCount,
|
|
|
|
int32_t aModifiers,
|
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool aToWindow,
|
|
|
|
bool* aPreventDefault)
|
2011-12-17 00:24:11 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-12-17 00:24:11 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t msg;
|
2011-12-17 00:24:11 +00:00
|
|
|
if (aType.EqualsLiteral("touchstart")) {
|
|
|
|
msg = NS_TOUCH_START;
|
|
|
|
} else if (aType.EqualsLiteral("touchmove")) {
|
|
|
|
msg = NS_TOUCH_MOVE;
|
|
|
|
} else if (aType.EqualsLiteral("touchend")) {
|
|
|
|
msg = NS_TOUCH_END;
|
|
|
|
} else if (aType.EqualsLiteral("touchcancel")) {
|
|
|
|
msg = NS_TOUCH_CANCEL;
|
|
|
|
} else {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2013-09-27 06:20:57 +00:00
|
|
|
WidgetTouchEvent event(true, msg, widget);
|
2012-04-25 03:00:02 +00:00
|
|
|
event.modifiers = GetWidgetModifiers(aModifiers);
|
2011-12-17 00:24:11 +00:00
|
|
|
event.widget = widget;
|
|
|
|
event.time = PR_Now();
|
|
|
|
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
event.touches.SetCapacity(aCount);
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t i = 0; i < aCount; ++i) {
|
2013-08-02 07:05:16 +00:00
|
|
|
LayoutDeviceIntPoint pt =
|
|
|
|
ToWidgetPoint(CSSPoint(aXs[i], aYs[i]), offset, presContext);
|
2013-05-17 20:17:53 +00:00
|
|
|
nsRefPtr<Touch> t = new Touch(aIdentifiers[i],
|
2013-08-02 07:05:16 +00:00
|
|
|
LayoutDeviceIntPoint::ToUntyped(pt),
|
2013-05-17 20:17:53 +00:00
|
|
|
nsIntPoint(aRxs[i], aRys[i]),
|
|
|
|
aRotationAngles[i],
|
|
|
|
aForces[i]);
|
2011-12-17 00:24:11 +00:00
|
|
|
event.touches.AppendElement(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsEventStatus status;
|
2013-12-03 15:10:47 +00:00
|
|
|
if (aToWindow) {
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsViewManager* viewManager = presShell->GetViewManager();
|
|
|
|
if (!viewManager) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsView* view = viewManager->GetRootView();
|
|
|
|
if (!view) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = nsEventStatus_eIgnore;
|
|
|
|
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
|
|
|
|
return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
|
|
|
|
}
|
|
|
|
|
2011-12-17 00:24:11 +00:00
|
|
|
nsresult rv = widget->DispatchEvent(&event, status);
|
|
|
|
*aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2007-02-26 21:14:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendKeyEvent(const nsAString& aType,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aKeyCode,
|
|
|
|
int32_t aCharCode,
|
|
|
|
int32_t aModifiers,
|
|
|
|
uint32_t aAdditionalFlags,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool* aDefaultActionTaken)
|
2007-02-26 21:14:19 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2007-02-26 21:14:19 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2007-02-26 21:14:19 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
2007-07-26 04:14:33 +00:00
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
2007-02-26 21:14:19 +00:00
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t msg;
|
2007-02-26 21:14:19 +00:00
|
|
|
if (aType.EqualsLiteral("keydown"))
|
|
|
|
msg = NS_KEY_DOWN;
|
|
|
|
else if (aType.EqualsLiteral("keyup"))
|
|
|
|
msg = NS_KEY_UP;
|
|
|
|
else if (aType.EqualsLiteral("keypress"))
|
|
|
|
msg = NS_KEY_PRESS;
|
|
|
|
else
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-10-01 07:22:58 +00:00
|
|
|
WidgetKeyboardEvent event(true, msg, widget);
|
2012-04-25 03:00:02 +00:00
|
|
|
event.modifiers = GetWidgetModifiers(aModifiers);
|
2007-02-26 21:14:19 +00:00
|
|
|
|
2012-05-03 08:35:02 +00:00
|
|
|
if (msg == NS_KEY_PRESS) {
|
|
|
|
event.keyCode = aCharCode ? 0 : aKeyCode;
|
|
|
|
event.charCode = aCharCode;
|
|
|
|
} else {
|
|
|
|
event.keyCode = aKeyCode;
|
|
|
|
event.charCode = 0;
|
|
|
|
}
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t locationFlag = (aAdditionalFlags &
|
2012-05-03 08:35:02 +00:00
|
|
|
(KEY_FLAG_LOCATION_STANDARD | KEY_FLAG_LOCATION_LEFT |
|
|
|
|
KEY_FLAG_LOCATION_RIGHT | KEY_FLAG_LOCATION_NUMPAD |
|
|
|
|
KEY_FLAG_LOCATION_MOBILE | KEY_FLAG_LOCATION_JOYSTICK));
|
|
|
|
switch (locationFlag) {
|
|
|
|
case KEY_FLAG_LOCATION_STANDARD:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD;
|
|
|
|
break;
|
|
|
|
case KEY_FLAG_LOCATION_LEFT:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT;
|
|
|
|
break;
|
|
|
|
case KEY_FLAG_LOCATION_RIGHT:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_RIGHT;
|
|
|
|
break;
|
|
|
|
case KEY_FLAG_LOCATION_NUMPAD:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD;
|
|
|
|
break;
|
|
|
|
case KEY_FLAG_LOCATION_MOBILE:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_MOBILE;
|
|
|
|
break;
|
|
|
|
case KEY_FLAG_LOCATION_JOYSTICK:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_JOYSTICK;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (locationFlag != 0) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
// If location flag isn't set, choose the location from keycode.
|
|
|
|
switch (aKeyCode) {
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD0:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD1:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD2:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD3:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD4:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD5:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD6:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD7:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD8:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_NUMPAD9:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_MULTIPLY:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_ADD:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_SEPARATOR:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_SUBTRACT:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_DECIMAL:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_DIVIDE:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD;
|
|
|
|
break;
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_SHIFT:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_CONTROL:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_ALT:
|
|
|
|
case nsIDOMKeyEvent::DOM_VK_META:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-02-26 21:14:19 +00:00
|
|
|
event.refPoint.x = event.refPoint.y = 0;
|
|
|
|
event.time = PR_IntervalNow();
|
2013-07-10 14:12:40 +00:00
|
|
|
event.mFlags.mIsSynthesizedForTests = true;
|
2007-02-26 21:14:19 +00:00
|
|
|
|
2012-05-03 08:35:02 +00:00
|
|
|
if (aAdditionalFlags & KEY_FLAG_PREVENT_DEFAULT) {
|
2012-12-16 01:26:04 +00:00
|
|
|
event.mFlags.mDefaultPrevented = true;
|
2008-08-25 18:31:38 +00:00
|
|
|
}
|
|
|
|
|
2007-02-26 21:14:19 +00:00
|
|
|
nsEventStatus status;
|
2008-08-25 18:31:38 +00:00
|
|
|
nsresult rv = widget->DispatchEvent(&event, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
*aDefaultActionTaken = (status != nsEventStatus_eConsumeNoDefault);
|
|
|
|
|
|
|
|
return NS_OK;
|
2007-02-26 21:14:19 +00:00
|
|
|
}
|
|
|
|
|
2008-05-05 23:01:07 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::SendNativeKeyEvent(int32_t aNativeKeyboardLayout,
|
|
|
|
int32_t aNativeKeyCode,
|
|
|
|
int32_t aModifiers,
|
2008-05-05 23:01:07 +00:00
|
|
|
const nsAString& aCharacters,
|
|
|
|
const nsAString& aUnmodifiedCharacters)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2008-05-05 23:01:07 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2008-05-05 23:01:07 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2008-05-07 04:46:37 +00:00
|
|
|
return widget->SynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode,
|
|
|
|
aModifiers, aCharacters, aUnmodifiedCharacters);
|
2008-05-05 23:01:07 +00:00
|
|
|
}
|
|
|
|
|
2009-09-23 02:31:37 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::SendNativeMouseEvent(int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
int32_t aNativeMessage,
|
|
|
|
int32_t aModifierFlags,
|
2009-09-23 02:31:37 +00:00
|
|
|
nsIDOMElement* aElement)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2009-09-23 02:31:37 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2009-09-23 02:31:37 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return widget->SynthesizeNativeMouseEvent(nsIntPoint(aScreenX, aScreenY),
|
|
|
|
aNativeMessage, aModifierFlags);
|
|
|
|
}
|
|
|
|
|
2012-03-22 00:59:12 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::SendNativeMouseScrollEvent(int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
uint32_t aNativeMessage,
|
2012-03-22 00:59:12 +00:00
|
|
|
double aDeltaX,
|
|
|
|
double aDeltaY,
|
|
|
|
double aDeltaZ,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aModifierFlags,
|
|
|
|
uint32_t aAdditionalFlags,
|
2012-03-22 00:59:12 +00:00
|
|
|
nsIDOMElement* aElement)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-03-22 00:59:12 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidgetForElement(aElement);
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return widget->SynthesizeNativeMouseScrollEvent(nsIntPoint(aScreenX,
|
|
|
|
aScreenY),
|
|
|
|
aNativeMessage,
|
|
|
|
aDeltaX, aDeltaY, aDeltaZ,
|
|
|
|
aModifierFlags,
|
|
|
|
aAdditionalFlags);
|
|
|
|
}
|
|
|
|
|
2013-12-14 20:40:55 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendNativeTouchPoint(uint32_t aPointerId,
|
|
|
|
uint32_t aTouchState,
|
|
|
|
int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
double aPressure,
|
|
|
|
uint32_t aOrientation)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aPressure < 0 || aPressure > 1 || aOrientation > 359) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
return widget->SynthesizeNativeTouchPoint(aPointerId,
|
|
|
|
(nsIWidget::TouchPointerState)aTouchState,
|
|
|
|
nsIntPoint(aScreenX, aScreenY),
|
|
|
|
aPressure, aOrientation);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendNativeTouchTap(int32_t aScreenX,
|
|
|
|
int32_t aScreenY,
|
|
|
|
bool aLongTap)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
return widget->SynthesizeNativeTouchTap(nsIntPoint(aScreenX, aScreenY), aLongTap);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ClearNativeTouchSequence()
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
return widget->ClearNativeTouchSequence();
|
|
|
|
}
|
|
|
|
|
2008-06-28 07:55:30 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ActivateNativeMenuItemAt(const nsAString& indexString)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2008-06-28 07:55:30 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2008-06-28 07:55:30 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
return widget->ActivateNativeMenuItemAt(indexString);
|
|
|
|
}
|
|
|
|
|
2008-07-28 04:46:33 +00:00
|
|
|
NS_IMETHODIMP
|
2008-10-30 05:36:01 +00:00
|
|
|
nsDOMWindowUtils::ForceUpdateNativeMenuAt(const nsAString& indexString)
|
2008-07-28 04:46:33 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2008-07-28 04:46:33 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2008-07-28 04:46:33 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2008-10-30 05:36:01 +00:00
|
|
|
return widget->ForceUpdateNativeMenuAt(indexString);
|
2008-07-28 04:46:33 +00:00
|
|
|
}
|
|
|
|
|
2007-02-26 21:14:19 +00:00
|
|
|
nsIWidget*
|
2008-11-26 21:52:42 +00:00
|
|
|
nsDOMWindowUtils::GetWidget(nsPoint* aOffset)
|
2007-02-26 21:14:19 +00:00
|
|
|
{
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
if (window) {
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2007-02-26 21:14:19 +00:00
|
|
|
if (docShell) {
|
2012-12-29 01:56:42 +00:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2007-03-02 03:57:16 +00:00
|
|
|
if (presShell) {
|
|
|
|
nsIFrame* frame = presShell->GetRootFrame();
|
|
|
|
if (frame)
|
2008-11-26 21:52:42 +00:00
|
|
|
return frame->GetView()->GetNearestWidget(aOffset);
|
2007-03-02 03:57:16 +00:00
|
|
|
}
|
2007-02-26 21:14:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2007-02-26 21:14:19 +00:00
|
|
|
}
|
2007-07-12 22:57:17 +00:00
|
|
|
|
2009-09-23 02:31:37 +00:00
|
|
|
nsIWidget*
|
|
|
|
nsDOMWindowUtils::GetWidgetForElement(nsIDOMElement* aElement)
|
|
|
|
{
|
|
|
|
if (!aElement)
|
|
|
|
return GetWidget();
|
|
|
|
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
nsIDocument* doc = content->GetCurrentDoc();
|
2012-07-30 14:20:58 +00:00
|
|
|
nsIPresShell* presShell = doc ? doc->GetShell() : nullptr;
|
2009-09-23 02:31:37 +00:00
|
|
|
|
|
|
|
if (presShell) {
|
2009-12-24 21:20:06 +00:00
|
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
2009-09-23 02:31:37 +00:00
|
|
|
if (!frame) {
|
|
|
|
frame = presShell->GetRootFrame();
|
|
|
|
}
|
|
|
|
if (frame)
|
2010-07-02 19:11:04 +00:00
|
|
|
return frame->GetNearestWidget();
|
2009-09-23 02:31:37 +00:00
|
|
|
}
|
|
|
|
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2009-09-23 02:31:37 +00:00
|
|
|
}
|
|
|
|
|
2007-07-12 22:57:17 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::Focus(nsIDOMElement* aElement)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2007-10-10 21:03:12 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2007-10-10 21:03:12 +00:00
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsIDOMWindow> window = do_QueryReferent(mWindow);
|
Bug 178324, refactor focus by moving all focus handling into one place and simplifying it, add many tests, fixes many other bugs too numerous to mention in this small checkin comment, r=josh,smichaud,ere,dbaron,marco,neil,gavin,smaug,sr=smaug (CLOSED TREE)
2009-06-10 18:00:39 +00:00
|
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
|
|
if (fm) {
|
|
|
|
if (aElement)
|
|
|
|
fm->SetFocus(aElement, 0);
|
|
|
|
else
|
2012-04-02 02:23:51 +00:00
|
|
|
fm->ClearFocus(window);
|
2007-07-12 22:57:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2007-10-19 21:36:20 +00:00
|
|
|
NS_IMETHODIMP
|
2012-01-30 20:06:18 +00:00
|
|
|
nsDOMWindowUtils::GarbageCollect(nsICycleCollectorListener *aListener,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aExtraForgetSkippableCalls)
|
2007-10-19 21:36:20 +00:00
|
|
|
{
|
2013-03-16 04:47:02 +00:00
|
|
|
PROFILER_LABEL("GC", "GarbageCollect");
|
2010-07-20 06:31:01 +00:00
|
|
|
// Always permit this in debug builds.
|
2007-10-19 21:36:20 +00:00
|
|
|
#ifndef DEBUG
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2007-10-19 21:36:20 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2007-10-19 21:36:20 +00:00
|
|
|
#endif
|
|
|
|
|
2013-03-19 10:35:41 +00:00
|
|
|
nsJSContext::GarbageCollectNow(JS::gcreason::DOM_UTILS);
|
2012-08-10 21:16:05 +00:00
|
|
|
nsJSContext::CycleCollectNow(aListener, aExtraForgetSkippableCalls);
|
2007-10-19 21:36:20 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2008-08-27 21:24:03 +00:00
|
|
|
|
2011-07-26 17:11:15 +00:00
|
|
|
NS_IMETHODIMP
|
2012-01-30 20:06:18 +00:00
|
|
|
nsDOMWindowUtils::CycleCollect(nsICycleCollectorListener *aListener,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aExtraForgetSkippableCalls)
|
2011-07-26 17:11:15 +00:00
|
|
|
{
|
|
|
|
// Always permit this in debug builds.
|
|
|
|
#ifndef DEBUG
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-07-26 17:11:15 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-01-30 20:06:18 +00:00
|
|
|
nsJSContext::CycleCollectNow(aListener, aExtraForgetSkippableCalls);
|
2011-07-26 17:11:15 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2008-08-27 21:24:03 +00:00
|
|
|
|
2008-10-23 20:15:20 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SendSimpleGestureEvent(const nsAString& aType,
|
2009-01-03 12:40:26 +00:00
|
|
|
float aX,
|
|
|
|
float aY,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aDirection,
|
2012-08-09 07:09:42 +00:00
|
|
|
double aDelta,
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t aModifiers,
|
|
|
|
uint32_t aClickCount)
|
2008-10-23 20:15:20 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2008-10-23 20:15:20 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2008-10-23 20:15:20 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
2009-01-03 12:40:26 +00:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2008-10-23 20:15:20 +00:00
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t msg;
|
2013-04-09 19:44:01 +00:00
|
|
|
if (aType.EqualsLiteral("MozSwipeGestureStart"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_SWIPE_START;
|
|
|
|
else if (aType.EqualsLiteral("MozSwipeGestureUpdate"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_SWIPE_UPDATE;
|
|
|
|
else if (aType.EqualsLiteral("MozSwipeGestureEnd"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_SWIPE_END;
|
|
|
|
else if (aType.EqualsLiteral("MozSwipeGesture"))
|
2008-10-23 20:15:20 +00:00
|
|
|
msg = NS_SIMPLE_GESTURE_SWIPE;
|
|
|
|
else if (aType.EqualsLiteral("MozMagnifyGestureStart"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_MAGNIFY_START;
|
|
|
|
else if (aType.EqualsLiteral("MozMagnifyGestureUpdate"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_MAGNIFY_UPDATE;
|
|
|
|
else if (aType.EqualsLiteral("MozMagnifyGesture"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_MAGNIFY;
|
|
|
|
else if (aType.EqualsLiteral("MozRotateGestureStart"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_ROTATE_START;
|
|
|
|
else if (aType.EqualsLiteral("MozRotateGestureUpdate"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_ROTATE_UPDATE;
|
|
|
|
else if (aType.EqualsLiteral("MozRotateGesture"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_ROTATE;
|
2009-04-02 19:34:31 +00:00
|
|
|
else if (aType.EqualsLiteral("MozTapGesture"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_TAP;
|
|
|
|
else if (aType.EqualsLiteral("MozPressTapGesture"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_PRESSTAP;
|
2013-05-17 04:22:21 +00:00
|
|
|
else if (aType.EqualsLiteral("MozEdgeUIStarted"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_EDGE_STARTED;
|
|
|
|
else if (aType.EqualsLiteral("MozEdgeUICanceled"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_EDGE_CANCELED;
|
|
|
|
else if (aType.EqualsLiteral("MozEdgeUICompleted"))
|
|
|
|
msg = NS_SIMPLE_GESTURE_EDGE_COMPLETED;
|
2008-10-23 20:15:20 +00:00
|
|
|
else
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2014-02-15 01:06:06 +00:00
|
|
|
WidgetSimpleGestureEvent event(true, msg, widget);
|
2012-04-25 03:00:02 +00:00
|
|
|
event.modifiers = GetWidgetModifiers(aModifiers);
|
2014-02-15 01:06:06 +00:00
|
|
|
event.direction = aDirection;
|
|
|
|
event.delta = aDelta;
|
2012-06-14 17:40:12 +00:00
|
|
|
event.clickCount = aClickCount;
|
2008-10-23 20:15:20 +00:00
|
|
|
event.time = PR_IntervalNow();
|
|
|
|
|
2010-07-19 02:23:48 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-08-02 07:05:16 +00:00
|
|
|
event.refPoint = ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
|
2009-01-03 12:40:26 +00:00
|
|
|
|
2008-10-23 20:15:20 +00:00
|
|
|
nsEventStatus status;
|
|
|
|
return widget->DispatchEvent(&event, status);
|
|
|
|
}
|
2008-11-05 03:58:22 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2010-04-03 11:34:24 +00:00
|
|
|
nsDOMWindowUtils::ElementFromPoint(float aX, float aY,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool aFlushLayout,
|
2008-11-05 03:58:22 +00:00
|
|
|
nsIDOMElement** aReturn)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2008-11-05 03:58:22 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
2009-03-30 12:19:06 +00:00
|
|
|
|
2012-12-22 08:27:27 +00:00
|
|
|
Element* el =
|
|
|
|
doc->ElementFromPointHelper(aX, aY, aIgnoreRootScrollFrame, aFlushLayout);
|
|
|
|
nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(el);
|
|
|
|
retval.forget(aReturn);
|
|
|
|
return NS_OK;
|
2008-11-05 03:58:22 +00:00
|
|
|
}
|
2008-12-03 01:34:07 +00:00
|
|
|
|
2010-04-08 00:31:26 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::NodesFromRect(float aX, float aY,
|
|
|
|
float aTopSize, float aRightSize,
|
|
|
|
float aBottomSize, float aLeftSize,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aIgnoreRootScrollFrame,
|
|
|
|
bool aFlushLayout,
|
2010-04-08 00:31:26 +00:00
|
|
|
nsIDOMNodeList** aReturn)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-01-28 00:54:03 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2010-04-08 00:31:26 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
return doc->NodesFromRectHelper(aX, aY, aTopSize, aRightSize, aBottomSize, aLeftSize,
|
|
|
|
aIgnoreRootScrollFrame, aFlushLayout, aReturn);
|
|
|
|
}
|
|
|
|
|
2013-12-11 21:05:27 +00:00
|
|
|
static TemporaryRef<DataSourceSurface>
|
|
|
|
CanvasToDataSourceSurface(nsIDOMHTMLCanvasElement* aCanvas)
|
2008-12-03 01:34:07 +00:00
|
|
|
{
|
2011-12-03 21:50:16 +00:00
|
|
|
nsCOMPtr<nsINode> node = do_QueryInterface(aCanvas);
|
|
|
|
if (!node) {
|
2012-07-30 14:20:58 +00:00
|
|
|
return nullptr;
|
2011-12-03 21:50:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_ABORT_IF_FALSE(node->IsElement(),
|
|
|
|
"An nsINode that implements nsIDOMHTMLCanvasElement should "
|
|
|
|
"be an element.");
|
2010-02-24 19:04:32 +00:00
|
|
|
nsLayoutUtils::SurfaceFromElementResult result =
|
2013-12-11 21:05:27 +00:00
|
|
|
nsLayoutUtils::SurfaceFromElement(node->AsElement());
|
|
|
|
return result.mSourceSurface->GetDataSurface();
|
2008-12-03 01:34:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::CompareCanvases(nsIDOMHTMLCanvasElement *aCanvas1,
|
|
|
|
nsIDOMHTMLCanvasElement *aCanvas2,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t* aMaxDifference,
|
|
|
|
uint32_t* retVal)
|
2008-12-03 01:34:07 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2008-12-03 01:34:07 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2008-12-03 01:34:07 +00:00
|
|
|
|
2012-07-30 14:20:58 +00:00
|
|
|
if (aCanvas1 == nullptr ||
|
|
|
|
aCanvas2 == nullptr ||
|
|
|
|
retVal == nullptr)
|
2008-12-03 01:34:07 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-12-11 21:05:27 +00:00
|
|
|
RefPtr<DataSourceSurface> img1 = CanvasToDataSourceSurface(aCanvas1);
|
|
|
|
RefPtr<DataSourceSurface> img2 = CanvasToDataSourceSurface(aCanvas2);
|
2008-12-03 01:34:07 +00:00
|
|
|
|
2012-07-30 14:20:58 +00:00
|
|
|
if (img1 == nullptr || img2 == nullptr ||
|
2008-12-03 01:34:07 +00:00
|
|
|
img1->GetSize() != img2->GetSize() ||
|
|
|
|
img1->Stride() != img2->Stride())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
int v;
|
2013-12-11 21:05:27 +00:00
|
|
|
IntSize size = img1->GetSize();
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t stride = img1->Stride();
|
2008-12-03 01:34:07 +00:00
|
|
|
|
|
|
|
// we can optimize for the common all-pass case
|
2012-08-22 15:56:38 +00:00
|
|
|
if (stride == (uint32_t) size.width * 4) {
|
2013-12-11 21:05:27 +00:00
|
|
|
v = memcmp(img1->GetData(), img2->GetData(), size.width * size.height * 4);
|
2008-12-03 01:34:07 +00:00
|
|
|
if (v == 0) {
|
|
|
|
if (aMaxDifference)
|
|
|
|
*aMaxDifference = 0;
|
|
|
|
*retVal = 0;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t dc = 0;
|
|
|
|
uint32_t different = 0;
|
2008-12-03 01:34:07 +00:00
|
|
|
|
|
|
|
for (int j = 0; j < size.height; j++) {
|
2013-12-11 21:05:27 +00:00
|
|
|
unsigned char *p1 = img1->GetData() + j*stride;
|
|
|
|
unsigned char *p2 = img2->GetData() + j*stride;
|
2008-12-03 01:34:07 +00:00
|
|
|
v = memcmp(p1, p2, stride);
|
|
|
|
|
|
|
|
if (v) {
|
|
|
|
for (int i = 0; i < size.width; i++) {
|
2012-08-22 15:56:38 +00:00
|
|
|
if (*(uint32_t*) p1 != *(uint32_t*) p2) {
|
2008-12-03 01:34:07 +00:00
|
|
|
|
|
|
|
different++;
|
|
|
|
|
2013-01-15 12:22:03 +00:00
|
|
|
dc = std::max((uint32_t)abs(p1[0] - p2[0]), dc);
|
|
|
|
dc = std::max((uint32_t)abs(p1[1] - p2[1]), dc);
|
|
|
|
dc = std::max((uint32_t)abs(p1[2] - p2[2]), dc);
|
|
|
|
dc = std::max((uint32_t)abs(p1[3] - p2[3]), dc);
|
2008-12-03 01:34:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
p1 += 4;
|
|
|
|
p2 += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aMaxDifference)
|
|
|
|
*aMaxDifference = dc;
|
|
|
|
|
|
|
|
*retVal = different;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-01-06 01:15:13 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::GetIsMozAfterPaintPending(bool *aResult)
|
2009-01-06 01:15:13 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
2011-10-17 14:59:28 +00:00
|
|
|
*aResult = false;
|
2009-01-06 01:15:13 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_OK;
|
|
|
|
*aResult = presContext->IsDOMPaintEventPending();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-02-12 10:44:38 +00:00
|
|
|
|
2009-02-27 00:21:55 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ClearMozAfterPaintEvents()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2009-02-27 00:21:55 +00:00
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_OK;
|
|
|
|
presContext->ClearMozAfterPaintEvents();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-02-12 10:44:38 +00:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::DisableNonTestMouseEvents(bool aDisable)
|
2009-02-12 10:44:38 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2009-02-12 10:44:38 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2009-02-12 10:44:38 +00:00
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2009-02-12 10:44:38 +00:00
|
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
2012-12-29 01:56:42 +00:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2009-02-12 10:44:38 +00:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
2010-03-31 12:45:32 +00:00
|
|
|
presShell->DisableNonTestMouseEvents(aDisable);
|
|
|
|
return NS_OK;
|
2009-02-12 10:44:38 +00:00
|
|
|
}
|
2009-03-03 20:11:14 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::SuppressEventHandling(bool aSuppress)
|
2009-03-03 20:11:14 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2009-03-03 20:11:14 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2009-03-03 20:11:14 +00:00
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2009-03-03 20:11:14 +00:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
if (aSuppress) {
|
2014-02-26 23:58:21 +00:00
|
|
|
doc->SuppressEventHandling(nsIDocument::eEvents);
|
2009-03-03 20:11:14 +00:00
|
|
|
} else {
|
2014-02-26 23:58:21 +00:00
|
|
|
doc->UnsuppressEventHandlingAndFireEvents(nsIDocument::eEvents, true);
|
2009-03-03 20:11:14 +00:00
|
|
|
}
|
2009-03-30 12:19:06 +00:00
|
|
|
|
2009-03-03 20:11:14 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-09-10 22:21:04 +00:00
|
|
|
static nsresult
|
2014-03-08 09:22:28 +00:00
|
|
|
getScrollXYAppUnits(nsWeakPtr aWindow, bool aFlushLayout, nsPoint& aScrollPos) {
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(aWindow);
|
|
|
|
nsCOMPtr<nsIDocument> doc = window ? window->GetExtantDoc() : nullptr;
|
2009-03-30 12:19:06 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
if (aFlushLayout) {
|
|
|
|
doc->FlushPendingNotifications(Flush_Layout);
|
|
|
|
}
|
|
|
|
|
2010-06-25 13:59:57 +00:00
|
|
|
nsIPresShell *presShell = doc->GetShell();
|
2009-03-30 12:19:06 +00:00
|
|
|
if (presShell) {
|
2009-09-03 03:57:46 +00:00
|
|
|
nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
|
|
|
|
if (sf) {
|
2013-09-10 22:21:04 +00:00
|
|
|
aScrollPos = sf->GetScrollPosition();
|
2009-03-30 12:19:06 +00:00
|
|
|
}
|
|
|
|
}
|
2013-09-10 22:21:04 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-03-30 12:19:06 +00:00
|
|
|
|
2013-09-10 22:21:04 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetScrollXY(bool aFlushLayout, int32_t* aScrollX, int32_t* aScrollY)
|
|
|
|
{
|
|
|
|
nsPoint scrollPos(0,0);
|
|
|
|
nsresult rv = getScrollXYAppUnits(mWindow, aFlushLayout, scrollPos);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2009-09-03 03:57:46 +00:00
|
|
|
*aScrollX = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.x);
|
|
|
|
*aScrollY = nsPresContext::AppUnitsToIntCSSPixels(scrollPos.y);
|
2009-03-30 12:19:06 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-05-05 06:15:23 +00:00
|
|
|
|
2013-09-10 22:21:04 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetScrollXYFloat(bool aFlushLayout, float* aScrollX, float* aScrollY)
|
|
|
|
{
|
|
|
|
nsPoint scrollPos(0,0);
|
|
|
|
nsresult rv = getScrollXYAppUnits(mWindow, aFlushLayout, scrollPos);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
*aScrollX = nsPresContext::AppUnitsToFloatCSSPixels(scrollPos.x);
|
|
|
|
*aScrollY = nsPresContext::AppUnitsToFloatCSSPixels(scrollPos.y);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-02-13 20:32:35 +00:00
|
|
|
NS_IMETHODIMP
|
2013-02-25 22:13:36 +00:00
|
|
|
nsDOMWindowUtils::GetScrollbarSize(bool aFlushLayout, int32_t* aWidth,
|
|
|
|
int32_t* aHeight)
|
2013-02-13 20:32:35 +00:00
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-02-25 22:13:36 +00:00
|
|
|
*aWidth = 0;
|
|
|
|
*aHeight = 0;
|
2013-02-13 20:32:35 +00:00
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-02-13 20:32:35 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
if (aFlushLayout) {
|
|
|
|
doc->FlushPendingNotifications(Flush_Layout);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = doc->GetShell();
|
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_NOT_AVAILABLE);
|
|
|
|
|
|
|
|
nsIScrollableFrame* scrollFrame = presShell->GetRootScrollFrameAsScrollable();
|
|
|
|
NS_ENSURE_TRUE(scrollFrame, NS_OK);
|
|
|
|
|
|
|
|
nsMargin sizes = scrollFrame->GetActualScrollbarSizes();
|
2013-02-25 22:13:36 +00:00
|
|
|
*aWidth = nsPresContext::AppUnitsToIntCSSPixels(sizes.LeftRight());
|
|
|
|
*aHeight = nsPresContext::AppUnitsToIntCSSPixels(sizes.TopBottom());
|
2013-02-13 20:32:35 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-06-04 06:06:29 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetBoundsWithoutFlushing(nsIDOMElement *aElement,
|
|
|
|
nsIDOMClientRect** aResult)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2013-09-20 10:21:03 +00:00
|
|
|
nsRefPtr<DOMRect> rect = new DOMRect(window);
|
2013-06-04 06:06:29 +00:00
|
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
|
|
|
|
|
|
|
if (frame) {
|
|
|
|
nsRect r = nsLayoutUtils::GetAllInFlowRectsUnion(frame,
|
|
|
|
nsLayoutUtils::GetContainingBlockForClientRect(frame),
|
|
|
|
nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS);
|
|
|
|
rect->SetLayoutRect(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
rect.forget(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-05-23 14:49:59 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetRootBounds(nsIDOMClientRect** aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsIDocument* doc = GetDocument();
|
2012-05-23 14:49:59 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
nsRect bounds(0, 0, 0, 0);
|
|
|
|
nsIPresShell* presShell = doc->GetShell();
|
|
|
|
if (presShell) {
|
|
|
|
nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
|
|
|
|
if (sf) {
|
|
|
|
bounds = sf->GetScrollRange();
|
|
|
|
bounds.width += sf->GetScrollPortRect().width;
|
|
|
|
bounds.height += sf->GetScrollPortRect().height;
|
|
|
|
} else if (presShell->GetRootFrame()) {
|
|
|
|
bounds = presShell->GetRootFrame()->GetRect();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
2013-09-20 10:21:03 +00:00
|
|
|
nsRefPtr<DOMRect> rect = new DOMRect(window);
|
2012-05-23 14:49:59 +00:00
|
|
|
rect->SetRect(nsPresContext::AppUnitsToFloatCSSPixels(bounds.x),
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(bounds.y),
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(bounds.width),
|
|
|
|
nsPresContext::AppUnitsToFloatCSSPixels(bounds.height));
|
2013-03-17 07:55:17 +00:00
|
|
|
rect.forget(aResult);
|
2012-05-23 14:49:59 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:15:23 +00:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::GetIMEIsOpen(bool *aState)
|
2009-05-05 06:15:23 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:15:23 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aState);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// Open state should not be available when IME is not enabled.
|
2011-11-27 11:51:52 +00:00
|
|
|
InputContext context = widget->GetInputContext();
|
2011-11-27 11:51:53 +00:00
|
|
|
if (context.mIMEState.mEnabled != IMEState::ENABLED) {
|
2009-05-05 06:15:23 +00:00
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
2011-11-27 11:51:52 +00:00
|
|
|
}
|
2009-05-05 06:15:23 +00:00
|
|
|
|
2011-11-27 11:51:53 +00:00
|
|
|
if (context.mIMEState.mOpen == IMEState::OPEN_STATE_NOT_SUPPORTED) {
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
}
|
|
|
|
*aState = (context.mIMEState.mOpen == IMEState::OPEN);
|
|
|
|
return NS_OK;
|
2009-05-05 06:15:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetIMEStatus(uint32_t *aState)
|
2009-05-05 06:15:23 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:15:23 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aState);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2011-11-27 11:51:52 +00:00
|
|
|
InputContext context = widget->GetInputContext();
|
2012-08-22 15:56:38 +00:00
|
|
|
*aState = static_cast<uint32_t>(context.mIMEState.mEnabled);
|
2010-11-23 06:48:45 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetFocusedInputType(char** aType)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2010-11-23 06:48:45 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aType);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2011-11-27 11:51:52 +00:00
|
|
|
InputContext context = widget->GetInputContext();
|
2010-11-23 06:48:45 +00:00
|
|
|
*aType = ToNewCString(context.mHTMLInputType);
|
|
|
|
return NS_OK;
|
2009-05-05 06:15:23 +00:00
|
|
|
}
|
|
|
|
|
2011-01-13 17:45:14 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::FindElementWithViewId(nsViewID aID,
|
|
|
|
nsIDOMElement** aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-01-13 17:45:14 +00:00
|
|
|
nsRefPtr<nsIContent> content = nsLayoutUtils::FindContentFor(aID);
|
2011-02-02 21:35:03 +00:00
|
|
|
return content ? CallQueryInterface(content, aResult) : NS_OK;
|
2011-01-13 17:45:14 +00:00
|
|
|
}
|
|
|
|
|
2013-08-08 19:56:09 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetViewId(nsIDOMElement* aElement, nsViewID* aResult)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
|
|
|
|
if (content && nsLayoutUtils::FindIDFor(content, aResult)) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
2009-08-03 21:41:36 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetScreenPixelsPerCSSPixel(float* aScreenPixels)
|
|
|
|
{
|
2012-08-22 20:17:26 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
return window->GetDevicePixelRatio(aScreenPixels);
|
2009-08-03 21:41:36 +00:00
|
|
|
}
|
2009-10-16 22:19:01 +00:00
|
|
|
|
2012-09-29 11:35:19 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetFullZoom(float* aFullZoom)
|
|
|
|
{
|
|
|
|
*aFullZoom = 1.0f;
|
|
|
|
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-29 11:35:19 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aFullZoom = presContext->DeviceContext()->GetPixelScale();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-10-29 11:11:02 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::DispatchDOMEventViaPresShell(nsIDOMNode* aTarget,
|
|
|
|
nsIDOMEvent* aEvent,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aTrusted,
|
|
|
|
bool* aRetVal)
|
2009-10-29 11:11:02 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2009-10-29 11:11:02 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-06-10 23:44:50 +00:00
|
|
|
NS_ENSURE_STATE(aEvent);
|
|
|
|
aEvent->SetTrusted(aTrusted);
|
2013-10-02 03:46:04 +00:00
|
|
|
WidgetEvent* internalEvent = aEvent->GetInternalNSEvent();
|
2009-10-29 11:11:02 +00:00
|
|
|
NS_ENSURE_STATE(internalEvent);
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aTarget);
|
|
|
|
NS_ENSURE_STATE(content);
|
2013-03-08 11:04:53 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
if (content->OwnerDoc()->GetWindow() != window) {
|
|
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> targetDoc = content->GetCurrentDoc();
|
|
|
|
NS_ENSURE_STATE(targetDoc);
|
|
|
|
nsRefPtr<nsIPresShell> targetShell = targetDoc->GetShell();
|
|
|
|
NS_ENSURE_STATE(targetShell);
|
2009-10-29 11:11:02 +00:00
|
|
|
|
2013-07-04 10:56:22 +00:00
|
|
|
targetDoc->FlushPendingNotifications(Flush_Layout);
|
|
|
|
|
2009-10-29 11:11:02 +00:00
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
2013-03-08 11:04:53 +00:00
|
|
|
targetShell->HandleEventWithTarget(internalEvent, nullptr, content, &status);
|
2009-10-29 11:11:02 +00:00
|
|
|
*aRetVal = (status != nsEventStatus_eConsumeNoDefault);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-12-14 21:58:50 +00:00
|
|
|
|
2010-03-19 05:02:53 +00:00
|
|
|
static void
|
2013-10-02 03:46:03 +00:00
|
|
|
InitEvent(WidgetGUIEvent& aEvent, LayoutDeviceIntPoint* aPt = nullptr)
|
2010-03-19 05:02:53 +00:00
|
|
|
{
|
|
|
|
if (aPt) {
|
|
|
|
aEvent.refPoint = *aPt;
|
|
|
|
}
|
|
|
|
aEvent.time = PR_IntervalNow();
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-22 09:17:41 +00:00
|
|
|
nsDOMWindowUtils::SendCompositionEvent(const nsAString& aType,
|
|
|
|
const nsAString& aData,
|
|
|
|
const nsAString& aLocale)
|
2010-03-19 05:02:53 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-03-19 05:02:53 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t msg;
|
2010-03-19 05:02:53 +00:00
|
|
|
if (aType.EqualsLiteral("compositionstart")) {
|
|
|
|
msg = NS_COMPOSITION_START;
|
|
|
|
} else if (aType.EqualsLiteral("compositionend")) {
|
|
|
|
msg = NS_COMPOSITION_END;
|
2011-09-22 09:17:41 +00:00
|
|
|
} else if (aType.EqualsLiteral("compositionupdate")) {
|
|
|
|
msg = NS_COMPOSITION_UPDATE;
|
2010-03-19 05:02:53 +00:00
|
|
|
} else {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2013-10-01 07:23:00 +00:00
|
|
|
WidgetCompositionEvent compositionEvent(true, msg, widget);
|
2010-03-19 05:02:53 +00:00
|
|
|
InitEvent(compositionEvent);
|
2011-09-22 09:17:41 +00:00
|
|
|
if (msg != NS_COMPOSITION_START) {
|
|
|
|
compositionEvent.data = aData;
|
|
|
|
}
|
2010-03-19 05:02:53 +00:00
|
|
|
|
2012-12-16 01:26:04 +00:00
|
|
|
compositionEvent.mFlags.mIsSynthesizedForTests = true;
|
2012-09-26 05:47:51 +00:00
|
|
|
|
2010-03-19 05:02:53 +00:00
|
|
|
nsEventStatus status;
|
|
|
|
nsresult rv = widget->DispatchEvent(&compositionEvent, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-09-12 15:19:00 +00:00
|
|
|
nsDOMWindowUtils::CreateCompositionStringSynthesizer(
|
|
|
|
nsICompositionStringSynthesizer** aResult)
|
2010-03-19 05:02:53 +00:00
|
|
|
{
|
2013-09-12 15:19:00 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
|
|
*aResult = nullptr;
|
|
|
|
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-03-19 05:02:53 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-09-12 15:19:00 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE);
|
2010-03-19 05:02:53 +00:00
|
|
|
|
2013-09-12 15:19:00 +00:00
|
|
|
NS_ADDREF(*aResult = new CompositionStringSynthesizer(window));
|
2010-03-19 05:02:53 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::SendQueryContentEvent(uint32_t aType,
|
|
|
|
uint32_t aOffset, uint32_t aLength,
|
|
|
|
int32_t aX, int32_t aY,
|
2010-03-19 05:02:53 +00:00
|
|
|
nsIQueryContentEventResult **aResult)
|
|
|
|
{
|
2012-07-30 14:20:58 +00:00
|
|
|
*aResult = nullptr;
|
2010-03-19 05:02:53 +00:00
|
|
|
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-03-19 05:02:53 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2010-07-27 13:38:03 +00:00
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2010-07-27 13:38:03 +00:00
|
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
|
2012-12-29 01:56:42 +00:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2010-07-27 13:38:03 +00:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
|
|
NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
|
|
|
|
|
2010-03-19 05:02:53 +00:00
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aType != NS_QUERY_SELECTED_TEXT &&
|
|
|
|
aType != NS_QUERY_TEXT_CONTENT &&
|
|
|
|
aType != NS_QUERY_CARET_RECT &&
|
|
|
|
aType != NS_QUERY_TEXT_RECT &&
|
|
|
|
aType != NS_QUERY_EDITOR_RECT &&
|
|
|
|
aType != NS_QUERY_CHARACTER_AT_POINT) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> targetWidget = widget;
|
2013-08-02 07:05:16 +00:00
|
|
|
LayoutDeviceIntPoint pt(aX, aY);
|
2010-03-19 05:02:53 +00:00
|
|
|
|
|
|
|
if (aType == QUERY_CHARACTER_AT_POINT) {
|
|
|
|
// Looking for the widget at the point.
|
2013-10-01 07:23:00 +00:00
|
|
|
WidgetQueryContentEvent dummyEvent(true, NS_QUERY_CONTENT_STATE, widget);
|
2010-03-19 05:02:53 +00:00
|
|
|
InitEvent(dummyEvent, &pt);
|
|
|
|
nsIFrame* popupFrame =
|
2010-07-27 13:38:03 +00:00
|
|
|
nsLayoutUtils::GetPopupFrameForEventCoordinates(presContext->GetRootPresContext(), &dummyEvent);
|
2010-03-19 05:02:53 +00:00
|
|
|
|
|
|
|
nsIntRect widgetBounds;
|
|
|
|
nsresult rv = widget->GetClientBounds(widgetBounds);
|
2010-04-11 19:57:08 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2011-12-01 21:35:42 +00:00
|
|
|
widgetBounds.MoveTo(0, 0);
|
2010-03-19 05:02:53 +00:00
|
|
|
|
|
|
|
// There is no popup frame at the point and the point isn't in our widget,
|
|
|
|
// we cannot process this request.
|
2013-08-02 07:05:16 +00:00
|
|
|
NS_ENSURE_TRUE(popupFrame ||
|
|
|
|
widgetBounds.Contains(LayoutDeviceIntPoint::ToUntyped(pt)),
|
2010-03-19 05:02:53 +00:00
|
|
|
NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Fire the event on the widget at the point
|
|
|
|
if (popupFrame) {
|
2010-07-02 19:11:04 +00:00
|
|
|
targetWidget = popupFrame->GetNearestWidget();
|
2010-03-19 05:02:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-02 07:05:16 +00:00
|
|
|
pt += LayoutDeviceIntPoint::FromUntyped(
|
|
|
|
widget->WidgetToScreenOffset() - targetWidget->WidgetToScreenOffset());
|
2010-03-19 05:02:53 +00:00
|
|
|
|
2013-10-01 07:23:00 +00:00
|
|
|
WidgetQueryContentEvent queryEvent(true, aType, targetWidget);
|
2010-03-19 05:02:53 +00:00
|
|
|
InitEvent(queryEvent, &pt);
|
|
|
|
|
|
|
|
switch (aType) {
|
|
|
|
case NS_QUERY_TEXT_CONTENT:
|
|
|
|
queryEvent.InitForQueryTextContent(aOffset, aLength);
|
|
|
|
break;
|
|
|
|
case NS_QUERY_CARET_RECT:
|
|
|
|
queryEvent.InitForQueryCaretRect(aOffset);
|
|
|
|
break;
|
|
|
|
case NS_QUERY_TEXT_RECT:
|
|
|
|
queryEvent.InitForQueryTextRect(aOffset, aLength);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
nsresult rv = targetWidget->DispatchEvent(&queryEvent, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsQueryContentEventResult* result = new nsQueryContentEventResult();
|
|
|
|
NS_ENSURE_TRUE(result, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
result->SetEventResult(widget, queryEvent);
|
|
|
|
NS_ADDREF(*aResult = result);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::SendSelectionSetEvent(uint32_t aOffset,
|
|
|
|
uint32_t aLength,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool aReverse,
|
|
|
|
bool *aResult)
|
2010-03-19 05:02:53 +00:00
|
|
|
{
|
2011-10-17 14:59:28 +00:00
|
|
|
*aResult = false;
|
2010-03-19 05:02:53 +00:00
|
|
|
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-03-19 05:02:53 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2013-10-01 07:23:01 +00:00
|
|
|
WidgetSelectionEvent selectionEvent(true, NS_SELECTION_SET, widget);
|
2010-03-19 05:02:53 +00:00
|
|
|
InitEvent(selectionEvent);
|
|
|
|
|
|
|
|
selectionEvent.mOffset = aOffset;
|
|
|
|
selectionEvent.mLength = aLength;
|
|
|
|
selectionEvent.mReversed = aReverse;
|
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
nsresult rv = widget->DispatchEvent(&selectionEvent, status);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
*aResult = selectionEvent.mSucceeded;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-12-14 21:58:50 +00:00
|
|
|
NS_IMETHODIMP
|
2010-01-11 01:45:45 +00:00
|
|
|
nsDOMWindowUtils::SendContentCommandEvent(const nsAString& aType,
|
|
|
|
nsITransferable * aTransferable)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-01-11 01:45:45 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
2010-03-19 05:03:41 +00:00
|
|
|
}
|
2010-01-11 01:45:45 +00:00
|
|
|
|
|
|
|
// get the widget to send the event to
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
int32_t msg;
|
2010-01-11 01:45:45 +00:00
|
|
|
if (aType.EqualsLiteral("cut"))
|
|
|
|
msg = NS_CONTENT_COMMAND_CUT;
|
|
|
|
else if (aType.EqualsLiteral("copy"))
|
|
|
|
msg = NS_CONTENT_COMMAND_COPY;
|
|
|
|
else if (aType.EqualsLiteral("paste"))
|
|
|
|
msg = NS_CONTENT_COMMAND_PASTE;
|
|
|
|
else if (aType.EqualsLiteral("delete"))
|
|
|
|
msg = NS_CONTENT_COMMAND_DELETE;
|
|
|
|
else if (aType.EqualsLiteral("undo"))
|
|
|
|
msg = NS_CONTENT_COMMAND_UNDO;
|
|
|
|
else if (aType.EqualsLiteral("redo"))
|
|
|
|
msg = NS_CONTENT_COMMAND_REDO;
|
|
|
|
else if (aType.EqualsLiteral("pasteTransferable"))
|
|
|
|
msg = NS_CONTENT_COMMAND_PASTE_TRANSFERABLE;
|
|
|
|
else
|
|
|
|
return NS_ERROR_FAILURE;
|
2013-05-27 23:47:45 +00:00
|
|
|
|
2013-09-27 06:20:54 +00:00
|
|
|
WidgetContentCommandEvent event(true, msg, widget);
|
2010-01-11 01:45:45 +00:00
|
|
|
if (msg == NS_CONTENT_COMMAND_PASTE_TRANSFERABLE) {
|
|
|
|
event.mTransferable = aTransferable;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsEventStatus status;
|
|
|
|
return widget->DispatchEvent(&event, status);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 17:39:36 +00:00
|
|
|
nsDOMWindowUtils::GetClassName(JS::Handle<JS::Value> aObject, JSContext* aCx,
|
|
|
|
char** aName)
|
2009-12-14 21:58:50 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2009-12-14 21:58:50 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Our argument must be a non-null object.
|
2011-12-03 21:50:16 +00:00
|
|
|
if (JSVAL_IS_PRIMITIVE(aObject)) {
|
2009-12-14 21:58:50 +00:00
|
|
|
return NS_ERROR_XPC_BAD_CONVERT_JS;
|
2011-12-03 21:50:16 +00:00
|
|
|
}
|
2009-12-14 21:58:50 +00:00
|
|
|
|
2012-02-04 00:54:57 +00:00
|
|
|
*aName = NS_strdup(JS_GetClass(JSVAL_TO_OBJECT(aObject))->name);
|
2011-12-03 21:50:16 +00:00
|
|
|
NS_ABORT_IF_FALSE(*aName, "NS_strdup should be infallible.");
|
|
|
|
return NS_OK;
|
2009-12-14 21:58:50 +00:00
|
|
|
}
|
2010-04-03 01:58:25 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetVisitedDependentComputedStyle(
|
|
|
|
nsIDOMElement *aElement, const nsAString& aPseudoElement,
|
|
|
|
const nsAString& aPropertyName, nsAString& aResult)
|
|
|
|
{
|
|
|
|
aResult.Truncate();
|
|
|
|
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-04-03 01:58:25 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2010-04-03 01:58:25 +00:00
|
|
|
nsCOMPtr<nsIDOMCSSStyleDeclaration> decl;
|
|
|
|
nsresult rv =
|
2012-04-02 02:23:51 +00:00
|
|
|
window->GetComputedStyle(aElement, aPseudoElement, getter_AddRefs(decl));
|
2010-04-03 01:58:25 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(true);
|
2010-04-03 01:58:25 +00:00
|
|
|
rv = decl->GetPropertyValue(aPropertyName, aResult);
|
2011-10-17 14:59:28 +00:00
|
|
|
static_cast<nsComputedDOMStyle*>(decl.get())->SetExposeVisitedStyle(false);
|
2010-04-03 01:58:25 +00:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
2010-04-11 20:51:00 +00:00
|
|
|
|
2010-07-01 21:53:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::EnterModalState()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
window->EnterModalState();
|
2010-07-01 21:53:00 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::LeaveModalState()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
2013-08-12 19:54:51 +00:00
|
|
|
window->LeaveModalState();
|
2010-07-01 21:53:00 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::IsInModalState(bool *retval)
|
2010-07-01 21:53:00 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*retval = static_cast<nsGlobalWindow*>(window.get())->IsInModalState();
|
2010-07-01 21:53:00 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-04-11 20:51:00 +00:00
|
|
|
NS_IMETHODIMP
|
2014-01-09 17:39:36 +00:00
|
|
|
nsDOMWindowUtils::GetParent(JS::Handle<JS::Value> aObject,
|
2011-11-16 07:50:19 +00:00
|
|
|
JSContext* aCx,
|
2014-01-09 17:39:36 +00:00
|
|
|
JS::MutableHandle<JS::Value> aParent)
|
2010-04-11 20:51:00 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-04-11 20:51:00 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-11-16 07:50:19 +00:00
|
|
|
// First argument must be an object.
|
2014-01-09 17:39:36 +00:00
|
|
|
if (aObject.isPrimitive()) {
|
2010-04-11 20:51:00 +00:00
|
|
|
return NS_ERROR_XPC_BAD_CONVERT_JS;
|
2011-11-16 07:50:19 +00:00
|
|
|
}
|
2010-04-11 20:51:00 +00:00
|
|
|
|
2014-01-09 17:39:36 +00:00
|
|
|
JS::Rooted<JSObject*> parent(aCx, JS_GetParent(&aObject.toObject()));
|
2010-05-05 01:02:00 +00:00
|
|
|
|
2010-06-12 16:29:04 +00:00
|
|
|
// Outerize if necessary.
|
2010-05-18 21:13:22 +00:00
|
|
|
if (parent) {
|
2011-11-16 07:50:19 +00:00
|
|
|
if (JSObjectOp outerize = js::GetObjectClass(parent)->ext.outerObject) {
|
2014-01-09 17:39:36 +00:00
|
|
|
parent = outerize(aCx, parent);
|
2011-11-16 07:50:19 +00:00
|
|
|
}
|
2010-05-05 01:02:00 +00:00
|
|
|
}
|
|
|
|
|
2014-01-09 17:39:36 +00:00
|
|
|
aParent.setObject(*parent);
|
2010-04-11 20:51:00 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-05-11 01:12:35 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetOuterWindowID(uint64_t *aWindowID)
|
2010-05-11 01:12:35 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
NS_ASSERTION(window->IsOuterWindow(), "How did that happen?");
|
|
|
|
*aWindowID = window->WindowID();
|
2010-05-11 01:12:35 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetCurrentInnerWindowID(uint64_t *aWindowID)
|
2010-05-11 01:12:35 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE);
|
|
|
|
|
|
|
|
NS_ASSERTION(window->IsOuterWindow(), "How did that happen?");
|
|
|
|
nsGlobalWindow* inner =
|
|
|
|
static_cast<nsGlobalWindow*>(window.get())->GetCurrentInnerWindowInternal();
|
2010-05-11 01:12:35 +00:00
|
|
|
if (!inner) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
2010-10-21 00:24:15 +00:00
|
|
|
*aWindowID = inner->WindowID();
|
2010-05-11 01:12:35 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-07-22 21:33:37 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SuspendTimeouts()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-07-22 21:33:37 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
window->SuspendTimeouts();
|
2010-07-22 21:33:37 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ResumeTimeouts()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-07-22 21:33:37 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
window->ResumeTimeouts();
|
2010-07-22 21:33:37 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-09-03 18:01:05 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetLayerManagerType(nsAString& aType)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2010-09-03 18:01:05 +00:00
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-03-15 04:41:52 +00:00
|
|
|
LayerManager *mgr = widget->GetLayerManager(nsIWidget::LAYER_MANAGER_PERSISTENT);
|
2010-09-03 18:01:05 +00:00
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
mgr->GetBackendName(aType);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-09-17 00:43:23 +00:00
|
|
|
|
Bug 825928: Land layers refactoring. r=jrmuizel,bas,nical,mattwoodrow,roc,nrc,benwa,bjacob,jgilbert,kchen CLOSED TREE
Please contact Bas Schouten <bschouten@mozilla.com>, Nicolas Silva <nsilva@mozilla.com> or Nicholas Cameron <ncameron@mozilla.com> with general questions. Below is a rough list of authors to contact with specific questions.
Authors:
gfx/layers/Compositor.* gfx/layers/Effects.h - Compositor Interface - bas,nrc,nical
gfx/layers/d3d* - D3D9/D3D10 - bas
gfx/layers/ThebesLayer* - ThebesLayers - nrc,bas
gfx/layers/composite/* - CompositeLayers - nrc,nical
gfx/layers/client/* - Client - nrc,nical,bas
gfx/layers/*Image* - nical
gfx/layers/ipc ipc - IPC - nical
gfx/layers/opengl - CompositorOGL - nrc,nical
gfx/2d - bas,nrc
gfx/gl - GLContext - bjacob
dom/* layout/* - DOM - mattwoodrow
2013-04-10 09:20:52 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetLayerManagerRemote(bool* retval)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
LayerManager *mgr = widget->GetLayerManager();
|
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
*retval = !!mgr->AsShadowForwarder();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-01-05 22:40:35 +00:00
|
|
|
NS_IMETHODIMP
|
2013-01-23 18:47:44 +00:00
|
|
|
nsDOMWindowUtils::StartFrameTimeRecording(uint32_t *startIndex)
|
2012-01-05 22:40:35 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-01-23 18:47:44 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(startIndex);
|
|
|
|
|
2012-01-05 22:40:35 +00:00
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
LayerManager *mgr = widget->GetLayerManager();
|
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-11-27 07:32:19 +00:00
|
|
|
const uint32_t kRecordingMinSize = 60 * 10; // 10 seconds @60 fps.
|
|
|
|
const uint32_t kRecordingMaxSize = 60 * 60 * 60; // One hour
|
|
|
|
uint32_t bufferSize = Preferences::GetUint("toolkit.framesRecording.bufferSize", uint32_t(0));
|
|
|
|
bufferSize = std::min(bufferSize, kRecordingMaxSize);
|
|
|
|
bufferSize = std::max(bufferSize, kRecordingMinSize);
|
|
|
|
*startIndex = mgr->StartFrameTimeRecording(bufferSize);
|
2012-01-05 22:40:35 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-01-23 18:47:44 +00:00
|
|
|
nsDOMWindowUtils::StopFrameTimeRecording(uint32_t startIndex,
|
|
|
|
uint32_t *frameCount,
|
|
|
|
float **frameIntervals)
|
2012-01-05 22:40:35 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-01-05 22:40:35 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(frameCount);
|
2013-01-04 02:53:15 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(frameIntervals);
|
2012-01-05 22:40:35 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
LayerManager *mgr = widget->GetLayerManager();
|
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2013-01-04 02:53:15 +00:00
|
|
|
nsTArray<float> tmpFrameIntervals;
|
2013-11-27 07:32:19 +00:00
|
|
|
mgr->StopFrameTimeRecording(startIndex, tmpFrameIntervals);
|
2013-01-04 02:53:15 +00:00
|
|
|
*frameCount = tmpFrameIntervals.Length();
|
2012-01-05 22:40:35 +00:00
|
|
|
|
2014-01-21 20:51:18 +00:00
|
|
|
*frameIntervals = (float*)nsMemory::Alloc(*frameCount * sizeof(float));
|
2012-01-05 22:40:35 +00:00
|
|
|
|
2013-01-23 18:47:44 +00:00
|
|
|
/* copy over the frame intervals and paint times into the arrays we just allocated */
|
|
|
|
for (uint32_t i = 0; i < *frameCount; i++) {
|
|
|
|
(*frameIntervals)[i] = tmpFrameIntervals[i];
|
2012-01-05 22:40:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-10-11 17:54:27 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::BeginTabSwitch()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-10-11 17:54:27 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
LayerManager *mgr = widget->GetLayerManager();
|
|
|
|
if (!mgr)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
mgr->BeginTabSwitch();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
static bool
|
2011-03-28 16:51:56 +00:00
|
|
|
ComputeAnimationValue(nsCSSProperty aProperty,
|
|
|
|
Element* aElement,
|
2010-10-23 23:31:55 +00:00
|
|
|
const nsAString& aInput,
|
|
|
|
nsStyleAnimation::Value& aOutput)
|
|
|
|
{
|
|
|
|
|
2011-03-28 16:51:56 +00:00
|
|
|
if (!nsStyleAnimation::ComputeValue(aProperty, aElement, aInput,
|
2011-10-17 14:59:28 +00:00
|
|
|
false, aOutput)) {
|
|
|
|
return false;
|
2010-10-23 23:31:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// This matches TransExtractComputedValue in nsTransitionManager.cpp.
|
|
|
|
if (aProperty == eCSSProperty_visibility) {
|
|
|
|
NS_ABORT_IF_FALSE(aOutput.GetUnit() == nsStyleAnimation::eUnit_Enumerated,
|
|
|
|
"unexpected unit");
|
|
|
|
aOutput.SetIntValue(aOutput.GetIntValue(),
|
|
|
|
nsStyleAnimation::eUnit_Visibility);
|
|
|
|
}
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
return true;
|
2010-10-23 23:31:55 +00:00
|
|
|
}
|
|
|
|
|
2011-04-12 06:18:43 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::AdvanceTimeAndRefresh(int64_t aMilliseconds)
|
2011-04-12 06:18:43 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-04-12 06:18:43 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-05-27 23:47:45 +00:00
|
|
|
nsRefreshDriver* driver = GetPresContext()->RefreshDriver();
|
|
|
|
driver->AdvanceTimeAndRefresh(aMilliseconds);
|
2014-02-12 04:41:57 +00:00
|
|
|
|
2014-03-21 21:59:57 +00:00
|
|
|
LayerTransactionChild* transaction = GetLayerTransaction();
|
|
|
|
if (transaction) {
|
|
|
|
transaction->SendSetTestSampleTime(driver->MostRecentRefresh());
|
2014-02-12 04:41:57 +00:00
|
|
|
}
|
2011-04-12 06:18:43 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::RestoreNormalRefresh()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-04-12 06:18:43 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-02-12 04:41:57 +00:00
|
|
|
// Kick the compositor out of test mode before the refresh driver, so that
|
|
|
|
// the refresh driver doesn't send an update that gets ignored by the
|
|
|
|
// compositor.
|
2014-03-21 21:59:57 +00:00
|
|
|
LayerTransactionChild* transaction = GetLayerTransaction();
|
|
|
|
if (transaction) {
|
|
|
|
transaction->SendLeaveTestMode();
|
2014-02-12 04:41:57 +00:00
|
|
|
}
|
|
|
|
|
2013-05-27 23:47:45 +00:00
|
|
|
nsRefreshDriver* driver = GetPresContext()->RefreshDriver();
|
|
|
|
driver->RestoreNormalRefresh();
|
2011-04-12 06:18:43 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-03-15 21:40:37 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsTestControllingRefreshes(bool *aResult)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-10-17 21:50:24 +00:00
|
|
|
nsPresContext* pc = GetPresContext();
|
2013-03-15 21:40:37 +00:00
|
|
|
*aResult =
|
2013-10-17 21:50:24 +00:00
|
|
|
pc ? pc->RefreshDriver()->IsTestControllingRefreshesEnabled() : false;
|
2013-03-15 21:40:37 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2014-02-14 08:59:23 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetAsyncScrollOffset(nsIDOMNode* aNode,
|
|
|
|
int32_t aX, int32_t aY)
|
|
|
|
{
|
|
|
|
nsCOMPtr<Element> element = do_QueryInterface(aNode);
|
|
|
|
if (!element) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
nsIFrame* frame = element->GetPrimaryFrame();
|
|
|
|
if (!frame) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
nsIScrollableFrame* scrollable = do_QueryFrame(frame);
|
|
|
|
nsPresContext* presContext = frame->PresContext();
|
|
|
|
nsIFrame* rootScrollFrame = presContext->PresShell()->GetRootScrollFrame();
|
|
|
|
if (!scrollable) {
|
|
|
|
if (rootScrollFrame && rootScrollFrame->GetContent() == element) {
|
|
|
|
frame = rootScrollFrame;
|
|
|
|
scrollable = do_QueryFrame(frame);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!scrollable) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
Layer* layer = FrameLayerBuilder::GetDedicatedLayer(scrollable->GetScrolledFrame(),
|
|
|
|
nsDisplayItem::TYPE_SCROLL_LAYER);
|
|
|
|
if (!layer) {
|
|
|
|
if (rootScrollFrame == frame && !presContext->GetParentPresContext()) {
|
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (widget) {
|
|
|
|
LayerManager* manager = widget->GetLayerManager();
|
|
|
|
if (manager) {
|
|
|
|
layer = manager->GetRoot();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!layer) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
|
|
|
|
if (!forwarder || !forwarder->HasShadowManager()) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
forwarder->GetShadowManager()->SendSetAsyncScrollOffset(
|
|
|
|
layer->AsShadowableLayer()->GetShadow(), aX, aY);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-10-23 23:31:55 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::ComputeAnimationDistance(nsIDOMElement* aElement,
|
|
|
|
const nsAString& aProperty,
|
|
|
|
const nsAString& aValue1,
|
|
|
|
const nsAString& aValue2,
|
|
|
|
double* aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-10-23 23:31:55 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
// Convert direction-dependent properties as appropriate, e.g.,
|
|
|
|
// border-left to border-left-value.
|
2014-03-07 17:14:23 +00:00
|
|
|
nsCSSProperty property =
|
|
|
|
nsCSSProps::LookupProperty(aProperty, nsCSSProps::eIgnoreEnabledState);
|
2010-10-23 23:31:55 +00:00
|
|
|
if (property != eCSSProperty_UNKNOWN && nsCSSProps::IsShorthand(property)) {
|
|
|
|
nsCSSProperty subprop0 = *nsCSSProps::SubpropertyEntryFor(property);
|
|
|
|
if (nsCSSProps::PropHasFlags(subprop0, CSS_PROPERTY_REPORT_OTHER_NAME) &&
|
|
|
|
nsCSSProps::OtherNameFor(subprop0) == property) {
|
|
|
|
property = subprop0;
|
|
|
|
} else {
|
|
|
|
property = eCSSProperty_UNKNOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ABORT_IF_FALSE(property == eCSSProperty_UNKNOWN ||
|
|
|
|
!nsCSSProps::IsShorthand(property),
|
|
|
|
"should not have shorthand");
|
|
|
|
|
|
|
|
nsStyleAnimation::Value v1, v2;
|
|
|
|
if (property == eCSSProperty_UNKNOWN ||
|
2011-03-28 16:51:56 +00:00
|
|
|
!ComputeAnimationValue(property, content->AsElement(), aValue1, v1) ||
|
|
|
|
!ComputeAnimationValue(property, content->AsElement(), aValue2, v2)) {
|
2010-10-23 23:31:55 +00:00
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!nsStyleAnimation::ComputeDistance(property, v1, v2, *aResult)) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-09-17 00:43:23 +00:00
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::RenderDocument(const nsRect& aRect,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t aFlags,
|
2010-09-17 00:43:23 +00:00
|
|
|
nscolor aBackgroundColor,
|
|
|
|
gfxContext* aThebesContext)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-07-23 23:39:17 +00:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
2010-09-17 00:43:23 +00:00
|
|
|
|
|
|
|
// Get Primary Shell
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
|
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
// Render Document
|
|
|
|
return presShell->RenderDocument(aRect, aFlags, aBackgroundColor, aThebesContext);
|
|
|
|
}
|
2010-09-17 18:56:53 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetCursorType(int16_t *aCursor)
|
2010-09-17 18:56:53 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2010-09-17 18:56:53 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aCursor);
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsIDocument* doc = GetDocument();
|
2010-09-17 18:56:53 +00:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
bool isSameDoc = false;
|
2010-09-17 18:56:53 +00:00
|
|
|
do {
|
2013-04-24 04:22:37 +00:00
|
|
|
if (nsEventStateManager::sMouseOverDocument == doc) {
|
2011-10-17 14:59:28 +00:00
|
|
|
isSameDoc = true;
|
2010-09-17 18:56:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while ((doc = doc->GetParentDocument()));
|
|
|
|
|
|
|
|
if (!isSameDoc) {
|
|
|
|
*aCursor = eCursor_none;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
// fetch cursor value from window's widget
|
|
|
|
*aCursor = widget->GetCursor();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2010-10-21 00:24:16 +00:00
|
|
|
|
2010-10-14 16:19:27 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetDisplayDPI(float *aDPI)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2010-10-14 16:19:27 +00:00
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
*aDPI = widget->GetDPI();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-21 00:24:16 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetOuterWindowWithId(uint64_t aWindowID,
|
2010-10-21 00:24:16 +00:00
|
|
|
nsIDOMWindow** aWindow)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2010-10-21 01:33:34 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-05-07 16:34:20 +00:00
|
|
|
// XXX This method is deprecated. See bug 865664.
|
|
|
|
nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
|
2013-08-21 19:28:26 +00:00
|
|
|
NS_LITERAL_CSTRING("DOM"),
|
2013-05-07 16:34:20 +00:00
|
|
|
nsContentUtils::GetDocumentFromCaller(),
|
|
|
|
nsContentUtils::eDOM_PROPERTIES,
|
|
|
|
"GetWindowWithOuterIdWarning");
|
|
|
|
|
2010-10-21 00:24:16 +00:00
|
|
|
*aWindow = nsGlobalWindow::GetOuterWindowWithId(aWindowID);
|
|
|
|
NS_IF_ADDREF(*aWindow);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2011-02-03 08:47:11 +00:00
|
|
|
|
2013-09-24 15:05:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetContainerElement(nsIDOMElement** aResult)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMElement> element =
|
|
|
|
do_QueryInterface(window->GetFrameElementInternal());
|
|
|
|
|
|
|
|
element.forget(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-09-27 00:25:41 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::WrapDOMFile(nsIFile *aFile,
|
2012-09-10 19:45:10 +00:00
|
|
|
nsIDOMFile **aDOMFile)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-09-25 15:04:25 +00:00
|
|
|
if (!aFile) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
2011-09-27 00:25:41 +00:00
|
|
|
NS_ADDREF(*aDOMFile = new nsDOMFileFile(aFile));
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-02-03 08:47:11 +00:00
|
|
|
#ifdef DEBUG
|
2011-09-29 06:19:26 +00:00
|
|
|
static bool
|
2011-02-03 08:47:11 +00:00
|
|
|
CheckLeafLayers(Layer* aLayer, const nsIntPoint& aOffset, nsIntRegion* aCoveredRegion)
|
|
|
|
{
|
2014-01-27 15:28:47 +00:00
|
|
|
gfx::Matrix transform;
|
2011-02-03 08:47:11 +00:00
|
|
|
if (!aLayer->GetTransform().Is2D(&transform) ||
|
|
|
|
transform.HasNonIntegerTranslation())
|
2011-10-17 14:59:28 +00:00
|
|
|
return false;
|
2011-02-03 08:47:11 +00:00
|
|
|
transform.NudgeToIntegers();
|
2014-01-27 15:28:47 +00:00
|
|
|
nsIntPoint offset = aOffset + nsIntPoint(transform._31, transform._32);
|
2011-02-03 08:47:11 +00:00
|
|
|
|
|
|
|
Layer* child = aLayer->GetFirstChild();
|
|
|
|
if (child) {
|
|
|
|
while (child) {
|
|
|
|
if (!CheckLeafLayers(child, offset, aCoveredRegion))
|
2011-10-17 14:59:28 +00:00
|
|
|
return false;
|
2011-02-03 08:47:11 +00:00
|
|
|
child = child->GetNextSibling();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
nsIntRegion rgn = aLayer->GetVisibleRegion();
|
|
|
|
rgn.MoveBy(offset);
|
|
|
|
nsIntRegion tmp;
|
|
|
|
tmp.And(rgn, *aCoveredRegion);
|
|
|
|
if (!tmp.IsEmpty())
|
2011-10-17 14:59:28 +00:00
|
|
|
return false;
|
2011-02-03 08:47:11 +00:00
|
|
|
aCoveredRegion->Or(*aCoveredRegion, rgn);
|
|
|
|
}
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
return true;
|
2011-02-03 08:47:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::LeafLayersPartitionWindow(bool* aResult)
|
2011-02-03 08:47:11 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-02-03 08:47:11 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
*aResult = true;
|
2011-02-03 08:47:11 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
nsIWidget* widget = GetWidget();
|
|
|
|
if (!widget)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
LayerManager* manager = widget->GetLayerManager();
|
|
|
|
if (!manager)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (!presContext)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
Layer* root = manager->GetRoot();
|
|
|
|
if (!root)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsIntPoint offset(0, 0);
|
|
|
|
nsIntRegion coveredRegion;
|
|
|
|
if (!CheckLeafLayers(root, offset, &coveredRegion)) {
|
2011-10-17 14:59:28 +00:00
|
|
|
*aResult = false;
|
2011-02-03 08:47:11 +00:00
|
|
|
}
|
|
|
|
if (!coveredRegion.IsEqual(root->GetVisibleRegion())) {
|
2011-10-17 14:59:28 +00:00
|
|
|
*aResult = false;
|
2011-02-03 08:47:11 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2011-04-26 12:31:21 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsDOMWindowUtils::GetMayHaveTouchEventListeners(bool* aResult)
|
2011-04-26 12:31:21 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-04-26 12:31:21 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
nsPIDOMWindow* innerWindow = window->GetCurrentInnerWindow();
|
2011-10-17 14:59:28 +00:00
|
|
|
*aResult = innerWindow ? innerWindow->HasTouchEventListeners() : false;
|
2011-04-26 12:31:21 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-10-26 03:23:26 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::CheckAndClearPaintedState(nsIDOMElement* aElement, bool* aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-10-26 03:23:26 +00:00
|
|
|
if (!aElement) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
|
|
|
|
|
|
|
if (!frame) {
|
|
|
|
*aResult = false;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = frame->CheckAndClearPaintedState();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-08-13 19:05:34 +00:00
|
|
|
NS_IMETHODIMP
|
2013-10-08 21:00:12 +00:00
|
|
|
nsDOMWindowUtils::EnableDialogs()
|
2012-08-13 19:05:34 +00:00
|
|
|
{
|
2013-10-08 21:00:12 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2012-08-13 19:05:34 +00:00
|
|
|
|
2013-10-08 21:00:12 +00:00
|
|
|
static_cast<nsGlobalWindow*>(window.get())->EnableDialogs();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::DisableDialogs()
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
static_cast<nsGlobalWindow*>(window.get())->DisableDialogs();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::AreDialogsEnabled(bool* aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-08-13 19:05:34 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
|
2013-10-08 21:00:12 +00:00
|
|
|
*aResult = static_cast<nsGlobalWindow*>(window.get())->AreDialogsEnabled();
|
2012-08-13 19:05:34 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-12-11 21:21:03 +00:00
|
|
|
static nsIDOMBlob*
|
|
|
|
GetXPConnectNative(JSContext* aCx, JSObject* aObj) {
|
|
|
|
nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(
|
|
|
|
nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, aObj));
|
|
|
|
return blob;
|
|
|
|
}
|
|
|
|
|
2012-06-03 16:33:52 +00:00
|
|
|
static nsresult
|
2014-01-31 09:56:40 +00:00
|
|
|
GetFileOrBlob(const nsAString& aName, JS::Handle<JS::Value> aBlobParts,
|
|
|
|
JS::Handle<JS::Value> aParameters, JSContext* aCx,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint8_t aOptionalArgCount, nsISupports** aResult)
|
2011-12-16 07:34:24 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-12-16 07:34:24 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-06-03 16:33:52 +00:00
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports> file;
|
|
|
|
|
|
|
|
if (aName.IsVoid()) {
|
|
|
|
rv = nsDOMMultipartFile::NewBlob(getter_AddRefs(file));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rv = nsDOMMultipartFile::NewFile(aName, getter_AddRefs(file));
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2012-12-11 21:21:03 +00:00
|
|
|
nsDOMMultipartFile* domFile =
|
|
|
|
static_cast<nsDOMMultipartFile*>(static_cast<nsIDOMFile*>(file.get()));
|
2012-06-03 16:33:52 +00:00
|
|
|
|
2014-01-31 09:56:40 +00:00
|
|
|
JS::AutoValueVector args(aCx);
|
|
|
|
MOZ_ALWAYS_TRUE(args.resize(2));
|
|
|
|
args[0] = aBlobParts;
|
|
|
|
args[1] = aParameters;
|
2012-06-03 16:33:52 +00:00
|
|
|
|
2014-01-31 09:56:40 +00:00
|
|
|
rv = domFile->InitBlob(aCx, aOptionalArgCount, args.begin(), GetXPConnectNative);
|
2012-06-03 16:33:52 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
file.forget(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 17:39:36 +00:00
|
|
|
nsDOMWindowUtils::GetFile(const nsAString& aName, JS::Handle<JS::Value> aBlobParts,
|
|
|
|
JS::Handle<JS::Value> aParameters, JSContext* aCx,
|
2012-08-22 15:56:38 +00:00
|
|
|
uint8_t aOptionalArgCount, nsIDOMFile** aResult)
|
2012-06-03 16:33:52 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-06-03 16:33:52 +00:00
|
|
|
nsCOMPtr<nsISupports> file;
|
|
|
|
nsresult rv = GetFileOrBlob(aName, aBlobParts, aParameters, aCx,
|
|
|
|
aOptionalArgCount, getter_AddRefs(file));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMFile> result = do_QueryInterface(file);
|
|
|
|
result.forget(aResult);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 17:39:36 +00:00
|
|
|
nsDOMWindowUtils::GetBlob(JS::Handle<JS::Value> aBlobParts,
|
|
|
|
JS::Handle<JS::Value> aParameters, JSContext* aCx,
|
2013-04-11 22:52:10 +00:00
|
|
|
uint8_t aOptionalArgCount, nsIDOMBlob** aResult)
|
2012-06-03 16:33:52 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-06-03 16:33:52 +00:00
|
|
|
nsCOMPtr<nsISupports> blob;
|
2012-08-24 18:51:33 +00:00
|
|
|
nsresult rv = GetFileOrBlob(NullString(), aBlobParts, aParameters, aCx,
|
2012-06-03 16:33:52 +00:00
|
|
|
aOptionalArgCount, getter_AddRefs(blob));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMBlob> result = do_QueryInterface(blob);
|
|
|
|
result.forget(aResult);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2014-01-09 17:39:36 +00:00
|
|
|
nsDOMWindowUtils::GetFileId(JS::Handle<JS::Value> aFile, JSContext* aCx,
|
2012-08-22 15:56:38 +00:00
|
|
|
int64_t* aResult)
|
2012-06-03 16:33:52 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
2012-06-03 16:33:52 +00:00
|
|
|
|
|
|
|
if (!JSVAL_IS_PRIMITIVE(aFile)) {
|
|
|
|
JSObject* obj = JSVAL_TO_OBJECT(aFile);
|
|
|
|
|
2014-02-24 20:56:13 +00:00
|
|
|
file::FileHandle* fileHandle;
|
|
|
|
if (NS_SUCCEEDED(UNWRAP_OBJECT(FileHandle, obj, fileHandle))) {
|
|
|
|
*aResult = fileHandle->GetFileId();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-06-03 16:33:52 +00:00
|
|
|
nsISupports* nativeObj =
|
|
|
|
nsContentUtils::XPConnect()->GetNativeOfWrapper(aCx, obj);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMBlob> blob = do_QueryInterface(nativeObj);
|
|
|
|
if (blob) {
|
|
|
|
*aResult = blob->GetFileId();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = -1;
|
2011-12-16 07:34:24 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2013-09-11 04:18:36 +00:00
|
|
|
nsDOMWindowUtils::GetFileReferences(const nsAString& aDatabaseName, int64_t aId,
|
2014-01-09 17:39:36 +00:00
|
|
|
JS::Handle<JS::Value> aOptions,
|
2013-09-11 04:18:36 +00:00
|
|
|
int32_t* aRefCnt, int32_t* aDBRefCnt,
|
|
|
|
int32_t* aSliceRefCnt, JSContext* aCx,
|
2011-12-16 07:34:24 +00:00
|
|
|
bool* aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2011-12-16 07:34:24 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
2011-12-16 07:34:24 +00:00
|
|
|
|
|
|
|
nsCString origin;
|
2013-09-11 04:18:36 +00:00
|
|
|
quota::PersistenceType defaultPersistenceType;
|
|
|
|
nsresult rv =
|
|
|
|
quota::QuotaManager::GetInfoFromWindow(window, nullptr, &origin, nullptr,
|
|
|
|
&defaultPersistenceType);
|
2011-12-16 07:34:24 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2013-09-11 04:18:36 +00:00
|
|
|
IDBOpenDBOptions options;
|
|
|
|
JS::Rooted<JS::Value> optionsVal(aCx, aOptions);
|
|
|
|
if (!options.Init(aCx, optionsVal)) {
|
|
|
|
return NS_ERROR_TYPE_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
quota::PersistenceType persistenceType =
|
|
|
|
quota::PersistenceTypeFromStorage(options.mStorage, defaultPersistenceType);
|
|
|
|
|
2011-12-16 07:34:24 +00:00
|
|
|
nsRefPtr<indexedDB::IndexedDatabaseManager> mgr =
|
2011-12-20 11:23:27 +00:00
|
|
|
indexedDB::IndexedDatabaseManager::Get();
|
|
|
|
|
|
|
|
if (mgr) {
|
2013-09-11 04:18:36 +00:00
|
|
|
rv = mgr->BlockAndGetFileReferences(persistenceType, origin, aDatabaseName,
|
|
|
|
aId, aRefCnt, aDBRefCnt, aSliceRefCnt,
|
|
|
|
aResult);
|
2013-06-05 08:11:23 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*aRefCnt = *aDBRefCnt = *aSliceRefCnt = -1;
|
|
|
|
*aResult = false;
|
2011-12-16 07:34:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2011-12-16 21:11:08 +00:00
|
|
|
|
2012-02-17 22:35:20 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::IsIncrementalGCEnabled(JSContext* cx, bool* aResult)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-03-19 10:35:41 +00:00
|
|
|
*aResult = JS::IsIncrementalGCEnabled(JS_GetRuntime(cx));
|
2012-02-17 22:35:20 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
NS_IMETHODIMP
|
2011-12-24 08:21:26 +00:00
|
|
|
nsDOMWindowUtils::StartPCCountProfiling(JSContext* cx)
|
2011-12-16 21:11:08 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
js::StartPCCountProfiling(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-12-24 08:21:26 +00:00
|
|
|
nsDOMWindowUtils::StopPCCountProfiling(JSContext* cx)
|
2011-12-16 21:11:08 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
js::StopPCCountProfiling(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-12-24 08:21:26 +00:00
|
|
|
nsDOMWindowUtils::PurgePCCounts(JSContext* cx)
|
2011-12-16 21:11:08 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
js::PurgePCCounts(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetPCCountScriptCount(JSContext* cx, int32_t *result)
|
2011-12-16 21:11:08 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
*result = js::GetPCCountScriptCount(cx);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetPCCountScriptSummary(int32_t script, JSContext* cx, nsAString& result)
|
2011-12-16 21:11:08 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
JSString *text = js::GetPCCountScriptSummary(cx, script);
|
|
|
|
if (!text)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsDependentJSString str;
|
|
|
|
if (!str.init(cx, text))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
result = str;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
nsDOMWindowUtils::GetPCCountScriptContents(int32_t script, JSContext* cx, nsAString& result)
|
2011-12-16 21:11:08 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2011-12-16 21:11:08 +00:00
|
|
|
JSString *text = js::GetPCCountScriptContents(cx, script);
|
|
|
|
if (!text)
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsDependentJSString str;
|
|
|
|
if (!str.init(cx, text))
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
result = str;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-01-04 06:52:20 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetPaintingSuppressed(bool *aPaintingSuppressed)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2012-04-02 02:23:51 +00:00
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
2012-01-04 06:52:20 +00:00
|
|
|
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
|
|
|
|
|
2012-12-29 01:56:42 +00:00
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
2012-01-04 06:52:20 +00:00
|
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
*aPaintingSuppressed = presShell->IsPaintingSuppressed();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:53:56 +00:00
|
|
|
NS_IMETHODIMP
|
2014-01-09 17:39:36 +00:00
|
|
|
nsDOMWindowUtils::GetPlugins(JSContext* cx, JS::MutableHandle<JS::Value> aPlugins)
|
2012-03-28 15:53:56 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-03-28 15:53:56 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
|
|
|
NS_ENSURE_STATE(doc);
|
2012-03-28 15:53:56 +00:00
|
|
|
|
|
|
|
nsTArray<nsIObjectLoadingContent*> plugins;
|
|
|
|
doc->GetPlugins(plugins);
|
|
|
|
|
2013-05-04 07:52:57 +00:00
|
|
|
JS::Rooted<JSObject*> jsPlugins(cx);
|
|
|
|
nsresult rv = nsTArrayToJSArray(cx, plugins, jsPlugins.address());
|
2012-03-31 05:34:16 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2014-01-09 17:39:36 +00:00
|
|
|
aPlugins.setObject(*jsPlugins);
|
2012-03-28 15:53:56 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-04-24 18:52:35 +00:00
|
|
|
|
2014-03-26 19:59:35 +00:00
|
|
|
static void
|
|
|
|
MaybeReflowForInflationScreenWidthChange(nsPresContext *aPresContext)
|
|
|
|
{
|
|
|
|
if (aPresContext) {
|
|
|
|
nsIPresShell* presShell = aPresContext->GetPresShell();
|
|
|
|
bool fontInflationWasEnabled = presShell->FontSizeInflationEnabled();
|
|
|
|
presShell->NotifyFontSizeInflationEnabledIsDirty();
|
|
|
|
bool changed = false;
|
|
|
|
if (presShell && presShell->FontSizeInflationEnabled() &&
|
|
|
|
presShell->FontSizeInflationMinTwips() != 0) {
|
|
|
|
aPresContext->ScreenWidthInchesForFontInflation(&changed);
|
|
|
|
}
|
|
|
|
|
|
|
|
changed = changed ||
|
|
|
|
(fontInflationWasEnabled != presShell->FontSizeInflationEnabled());
|
|
|
|
if (changed) {
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
|
|
|
|
if (docShell) {
|
|
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
|
|
docShell->GetContentViewer(getter_AddRefs(cv));
|
|
|
|
nsCOMPtr<nsIMarkupDocumentViewer> mudv = do_QueryInterface(cv);
|
|
|
|
if (mudv) {
|
|
|
|
nsTArray<nsCOMPtr<nsIMarkupDocumentViewer> > array;
|
|
|
|
mudv->AppendSubtree(array);
|
|
|
|
for (uint32_t i = 0, iEnd = array.Length(); i < iEnd; ++i) {
|
|
|
|
nsCOMPtr<nsIPresShell> shell;
|
|
|
|
nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(array[i]);
|
|
|
|
cv->GetPresShell(getter_AddRefs(shell));
|
|
|
|
if (shell) {
|
|
|
|
nsIFrame *rootFrame = shell->GetRootFrame();
|
|
|
|
if (rootFrame) {
|
|
|
|
shell->FrameNeedsReflow(rootFrame,
|
|
|
|
nsIPresShell::eStyleChange,
|
|
|
|
NS_FRAME_IS_DIRTY);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-24 18:52:35 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetScrollPositionClampingScrollPortSize(float aWidth, float aHeight)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-04-24 18:52:35 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(aWidth >= 0.0 && aHeight >= 0.0)) {
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
presShell->SetScrollPositionClampingScrollPortSize(
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aWidth),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aHeight));
|
|
|
|
|
2014-03-26 19:59:35 +00:00
|
|
|
// When the "font.size.inflation.minTwips" preference is set, the
|
|
|
|
// layout depends on the size of the screen. Since when the size
|
|
|
|
// of the screen changes, the scroll position clamping scroll port
|
|
|
|
// size also changes, we hook in the needed updates here rather
|
|
|
|
// than adding a separate notification just for this change.
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
MaybeReflowForInflationScreenWidthChange(presContext);
|
|
|
|
|
2012-04-24 18:52:35 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-05-11 00:56:21 +00:00
|
|
|
|
2013-03-07 10:17:33 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetContentDocumentFixedPositionMargins(float aTop, float aRight,
|
|
|
|
float aBottom, float aLeft)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(aTop >= 0.0f && aRight >= 0.0f && aBottom >= 0.0f && aLeft >= 0.0f)) {
|
|
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsMargin margins(nsPresContext::CSSPixelsToAppUnits(aTop),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aRight),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aBottom),
|
|
|
|
nsPresContext::CSSPixelsToAppUnits(aLeft));
|
|
|
|
presShell->SetContentDocumentFixedPositionMargins(margins);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-07-31 02:09:31 +00:00
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement,
|
|
|
|
const nsAString& aNewOrigin)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:37 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2012-07-31 02:09:31 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
doc->RemoteFrameFullscreenChanged(aFrameElement, aNewOrigin);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::RemoteFrameFullscreenReverted()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:37 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2012-07-31 02:09:31 +00:00
|
|
|
NS_ENSURE_STATE(doc);
|
|
|
|
|
|
|
|
doc->RemoteFrameFullscreenReverted();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsDOMWindowUtils::ExitFullscreen()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 19:45:37 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2013-02-26 05:40:53 +00:00
|
|
|
nsIDocument::ExitFullscreen(nullptr, /* async */ false);
|
2012-07-31 02:09:31 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-09-10 21:02:23 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-09-14 18:55:01 +00:00
|
|
|
nsDOMWindowUtils::SelectAtPoint(float aX, float aY, uint32_t aSelectBehavior,
|
2012-09-10 21:02:23 +00:00
|
|
|
bool *_retval)
|
|
|
|
{
|
|
|
|
*_retval = false;
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-10 21:02:23 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsSelectionAmount amount;
|
|
|
|
switch (aSelectBehavior) {
|
|
|
|
case nsIDOMWindowUtils::SELECT_CHARACTER:
|
|
|
|
amount = eSelectCharacter;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_CLUSTER:
|
|
|
|
amount = eSelectCluster;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_WORD:
|
|
|
|
amount = eSelectWord;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_LINE:
|
|
|
|
amount = eSelectLine;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_BEGINLINE:
|
|
|
|
amount = eSelectBeginLine;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_ENDLINE:
|
|
|
|
amount = eSelectEndLine;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_PARAGRAPH:
|
|
|
|
amount = eSelectParagraph;
|
|
|
|
break;
|
|
|
|
case nsIDOMWindowUtils::SELECT_WORDNOSPACE:
|
|
|
|
amount = eSelectWordNoSpace;
|
|
|
|
break;
|
2013-05-15 15:08:50 +00:00
|
|
|
default:
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
2012-09-10 21:02:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!presShell) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The root frame for this content window
|
|
|
|
nsIFrame* rootFrame = presShell->FrameManager()->GetRootFrame();
|
|
|
|
if (!rootFrame) {
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get the target frame at the client coordinates passed to us
|
2013-02-27 14:12:39 +00:00
|
|
|
nsPoint offset;
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetWidget(&offset);
|
2013-08-02 07:05:16 +00:00
|
|
|
nsIntPoint pt = LayoutDeviceIntPoint::ToUntyped(
|
|
|
|
ToWidgetPoint(CSSPoint(aX, aY), offset, GetPresContext()));
|
2012-09-10 21:02:23 +00:00
|
|
|
nsPoint ptInRoot =
|
|
|
|
nsLayoutUtils::GetEventCoordinatesRelativeTo(widget, pt, rootFrame);
|
|
|
|
nsIFrame* targetFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, ptInRoot);
|
|
|
|
// This can happen if the page hasn't loaded yet or if the point
|
|
|
|
// is outside the frame.
|
|
|
|
if (!targetFrame) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert point to coordinates relative to the target frame, which is
|
|
|
|
// what targetFrame's SelectByTypeAtPoint expects.
|
|
|
|
nsPoint relPoint =
|
|
|
|
nsLayoutUtils::GetEventCoordinatesRelativeTo(widget, pt, targetFrame);
|
|
|
|
|
|
|
|
nsresult rv =
|
|
|
|
static_cast<nsFrame*>(targetFrame)->
|
|
|
|
SelectByTypeAtPoint(GetPresContext(), relPoint, amount, amount,
|
|
|
|
nsFrame::SELECT_ACCUMULATE);
|
|
|
|
*_retval = !NS_FAILED(rv);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-09-11 11:51:10 +00:00
|
|
|
|
2012-10-29 11:21:15 +00:00
|
|
|
static nsIDocument::additionalSheetType
|
|
|
|
convertSheetType(uint32_t aSheetType)
|
|
|
|
{
|
|
|
|
switch(aSheetType) {
|
|
|
|
case nsDOMWindowUtils::AGENT_SHEET:
|
|
|
|
return nsIDocument::eAgentSheet;
|
|
|
|
case nsDOMWindowUtils::USER_SHEET:
|
|
|
|
return nsIDocument::eUserSheet;
|
|
|
|
case nsDOMWindowUtils::AUTHOR_SHEET:
|
|
|
|
return nsIDocument::eAuthorSheet;
|
|
|
|
default:
|
|
|
|
NS_ASSERTION(false, "wrong type");
|
|
|
|
// we must return something although this should never happen
|
|
|
|
return nsIDocument::SheetTypeCount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-11 11:51:10 +00:00
|
|
|
NS_IMETHODIMP
|
2012-09-14 18:55:01 +00:00
|
|
|
nsDOMWindowUtils::LoadSheet(nsIURI *aSheetURI, uint32_t aSheetType)
|
2012-09-11 11:51:10 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-11 11:51:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
2012-10-29 11:21:15 +00:00
|
|
|
NS_ENSURE_ARG(aSheetType == AGENT_SHEET ||
|
|
|
|
aSheetType == USER_SHEET ||
|
|
|
|
aSheetType == AUTHOR_SHEET);
|
2012-09-11 11:51:10 +00:00
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-07-23 23:39:17 +00:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
2012-09-11 11:51:10 +00:00
|
|
|
|
2012-10-29 11:21:15 +00:00
|
|
|
nsIDocument::additionalSheetType type = convertSheetType(aSheetType);
|
2012-09-11 11:51:10 +00:00
|
|
|
|
2013-07-23 23:39:17 +00:00
|
|
|
return doc->LoadAdditionalStyleSheet(type, aSheetURI);
|
2012-09-11 11:51:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-09-14 18:55:01 +00:00
|
|
|
nsDOMWindowUtils::RemoveSheet(nsIURI *aSheetURI, uint32_t aSheetType)
|
2012-09-11 11:51:10 +00:00
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-09-11 11:51:10 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
2012-10-29 11:21:15 +00:00
|
|
|
NS_ENSURE_ARG(aSheetType == AGENT_SHEET ||
|
|
|
|
aSheetType == USER_SHEET ||
|
|
|
|
aSheetType == AUTHOR_SHEET);
|
2012-09-11 11:51:10 +00:00
|
|
|
|
2014-03-08 09:22:28 +00:00
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
2013-07-23 23:39:17 +00:00
|
|
|
NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
|
2012-09-11 11:51:10 +00:00
|
|
|
|
2012-10-29 11:21:15 +00:00
|
|
|
nsIDocument::additionalSheetType type = convertSheetType(aSheetType);
|
2012-09-11 11:51:10 +00:00
|
|
|
|
|
|
|
doc->RemoveAdditionalStyleSheet(type, aSheetURI);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-10-08 11:02:57 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsHandlingUserInput(bool* aHandlingUserInput)
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-10-08 11:02:57 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aHandlingUserInput = nsEventStateManager::IsHandlingUserInput();
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-10-12 10:17:56 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::AllowScriptsToClose()
|
|
|
|
{
|
2012-10-25 23:10:53 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
2012-10-12 10:17:56 +00:00
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
static_cast<nsGlobalWindow*>(window.get())->AllowScriptsToClose();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2013-01-03 15:17:36 +00:00
|
|
|
|
2013-05-31 01:12:44 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetIsParentWindowMainWidgetVisible(bool* aIsVisible)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// this should reflect the "is parent window visible" logic in
|
|
|
|
// nsWindowWatcher::OpenWindowInternal()
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIWidget> parentWidget;
|
|
|
|
nsIDocShell *docShell = window->GetDocShell();
|
|
|
|
if (docShell) {
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> parentTreeOwner;
|
|
|
|
docShell->GetTreeOwner(getter_AddRefs(parentTreeOwner));
|
|
|
|
nsCOMPtr<nsIBaseWindow> parentWindow(do_GetInterface(parentTreeOwner));
|
|
|
|
if (parentWindow) {
|
|
|
|
parentWindow->GetMainWidget(getter_AddRefs(parentWidget));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!parentWidget) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aIsVisible = parentWidget->IsVisible();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-01-03 15:17:36 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::IsNodeDisabledForEvents(nsIDOMNode* aNode, bool* aRetVal)
|
|
|
|
{
|
|
|
|
*aRetVal = false;
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsINode> n = do_QueryInterface(aNode);
|
|
|
|
nsINode* node = n;
|
|
|
|
while (node) {
|
|
|
|
if (node->IsNodeOfType(nsINode::eHTML_FORM_CONTROL)) {
|
|
|
|
nsCOMPtr<nsIFormControl> fc = do_QueryInterface(node);
|
|
|
|
if (fc && fc->IsDisabledForEvents(NS_EVENT_NULL)) {
|
|
|
|
*aRetVal = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
node = node->GetParentNode();
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2013-01-16 09:27:06 +00:00
|
|
|
|
2013-03-12 18:01:00 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetPaintFlashing(bool aPaintFlashing)
|
|
|
|
{
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
2013-07-22 15:51:38 +00:00
|
|
|
presContext->SetPaintFlashing(aPaintFlashing);
|
2013-03-12 18:01:00 +00:00
|
|
|
// Clear paint flashing colors
|
|
|
|
nsIPresShell* presShell = GetPresShell();
|
|
|
|
if (!aPaintFlashing && presShell) {
|
|
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
|
|
|
if (rootFrame) {
|
|
|
|
rootFrame->InvalidateFrameSubtree();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetPaintFlashing(bool* aRetVal)
|
|
|
|
{
|
|
|
|
*aRetVal = false;
|
|
|
|
nsPresContext* presContext = GetPresContext();
|
|
|
|
if (presContext) {
|
2013-07-22 15:51:38 +00:00
|
|
|
*aRetVal = presContext->GetPaintFlashing();
|
2013-03-12 18:01:00 +00:00
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2013-01-16 09:27:06 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::DispatchEventToChromeOnly(nsIDOMEventTarget* aTarget,
|
|
|
|
nsIDOMEvent* aEvent,
|
|
|
|
bool* aRetVal)
|
|
|
|
{
|
|
|
|
*aRetVal = false;
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
NS_ENSURE_STATE(aTarget && aEvent);
|
|
|
|
aEvent->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true;
|
|
|
|
aTarget->DispatchEvent(aEvent, aRetVal);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2013-05-23 01:35:21 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::RunInStableState(nsIRunnable *runnable)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIAppShell> appShell(do_GetService(kAppShellCID));
|
|
|
|
if (!appShell) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return appShell->RunInStableState(runnable);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::RunBeforeNextEvent(nsIRunnable *runnable)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIAppShell> appShell(do_GetService(kAppShellCID));
|
|
|
|
if (!appShell) {
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return appShell->RunBeforeNextEvent(runnable);
|
|
|
|
}
|
|
|
|
|
2013-05-30 00:38:27 +00:00
|
|
|
NS_IMETHODIMP
|
2014-03-10 04:47:12 +00:00
|
|
|
nsDOMWindowUtils::GetOMTAStyle(nsIDOMElement* aElement,
|
|
|
|
const nsAString& aProperty,
|
|
|
|
nsAString& aResult)
|
2013-05-30 00:38:27 +00:00
|
|
|
{
|
2014-03-10 04:47:11 +00:00
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
2014-03-10 04:47:12 +00:00
|
|
|
nsCOMPtr<Element> element = do_QueryInterface(aElement);
|
2013-05-30 00:38:27 +00:00
|
|
|
if (!element) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsRefPtr<nsROCSSPrimitiveValue> cssValue = nullptr;
|
|
|
|
nsIFrame* frame = element->GetPrimaryFrame();
|
2013-05-31 18:06:56 +00:00
|
|
|
if (frame && nsLayoutUtils::AreAsyncAnimationsEnabled()) {
|
2013-05-30 00:38:27 +00:00
|
|
|
if (aProperty.EqualsLiteral("opacity")) {
|
2014-03-10 04:47:12 +00:00
|
|
|
Layer* layer =
|
|
|
|
FrameLayerBuilder::GetDedicatedLayer(frame,
|
|
|
|
nsDisplayItem::TYPE_OPACITY);
|
2013-05-30 00:38:27 +00:00
|
|
|
if (layer) {
|
|
|
|
float value;
|
|
|
|
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
|
2013-11-01 06:36:02 +00:00
|
|
|
if (forwarder && forwarder->HasShadowManager()) {
|
2014-03-10 04:47:12 +00:00
|
|
|
forwarder->GetShadowManager()->SendGetOpacity(
|
|
|
|
layer->AsShadowableLayer()->GetShadow(), &value);
|
2013-05-30 00:38:27 +00:00
|
|
|
cssValue = new nsROCSSPrimitiveValue;
|
|
|
|
cssValue->SetNumber(value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (aProperty.EqualsLiteral("transform")) {
|
2014-03-10 04:47:12 +00:00
|
|
|
Layer* layer =
|
|
|
|
FrameLayerBuilder::GetDedicatedLayer(frame,
|
|
|
|
nsDisplayItem::TYPE_TRANSFORM);
|
2013-05-30 00:38:27 +00:00
|
|
|
if (layer) {
|
|
|
|
ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
|
2013-11-01 06:36:02 +00:00
|
|
|
if (forwarder && forwarder->HasShadowManager()) {
|
2014-03-10 04:47:12 +00:00
|
|
|
MaybeTransform transform;
|
|
|
|
forwarder->GetShadowManager()->SendGetAnimationTransform(
|
|
|
|
layer->AsShadowableLayer()->GetShadow(), &transform);
|
|
|
|
if (transform.type() == MaybeTransform::Tgfx3DMatrix) {
|
|
|
|
cssValue =
|
|
|
|
nsComputedDOMStyle::MatrixToCSSValue(transform.get_gfx3DMatrix());
|
|
|
|
}
|
2013-05-30 00:38:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cssValue) {
|
|
|
|
nsString text;
|
2014-03-10 04:47:12 +00:00
|
|
|
ErrorResult rv;
|
2013-05-30 00:38:27 +00:00
|
|
|
cssValue->GetCssText(text, rv);
|
|
|
|
aResult.Assign(text);
|
|
|
|
return rv.ErrorCode();
|
2014-03-10 04:47:12 +00:00
|
|
|
} else {
|
|
|
|
aResult.Truncate();
|
2013-05-30 00:38:27 +00:00
|
|
|
}
|
|
|
|
|
2014-03-10 04:47:12 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetOMTAOrComputedStyle(nsIDOMElement* aElement,
|
|
|
|
const nsAString& aProperty,
|
|
|
|
nsAString& aResult)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to get OMTA style
|
|
|
|
nsresult rv = GetOMTAStyle(aElement, aProperty, aResult);
|
|
|
|
if (NS_FAILED(rv) || !aResult.IsEmpty()) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, fall back to computed style
|
|
|
|
nsCOMPtr<Element> element = do_QueryInterface(aElement);
|
|
|
|
if (!element) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
2013-05-30 00:38:27 +00:00
|
|
|
nsCOMPtr<nsIDOMCSSStyleDeclaration> style;
|
2014-03-10 04:47:12 +00:00
|
|
|
rv = element->GetCurrentDoc()->GetWindow()->
|
|
|
|
GetComputedStyle(aElement, aProperty, getter_AddRefs(style));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2013-05-30 00:38:27 +00:00
|
|
|
|
|
|
|
return style->GetPropertyValue(aProperty, aResult);
|
|
|
|
}
|
|
|
|
|
2014-03-11 10:46:55 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetAudioMuted(bool* aMuted)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*aMuted = window->GetAudioMuted();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetAudioMuted(bool aMuted)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
window->SetAudioMuted(aMuted);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::GetAudioVolume(float* aVolume)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
*aVolume = window->GetAudioVolume();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsDOMWindowUtils::SetAudioVolume(float aVolume)
|
|
|
|
{
|
|
|
|
if (!nsContentUtils::IsCallerChrome()) {
|
|
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryReferent(mWindow);
|
|
|
|
NS_ENSURE_STATE(window);
|
|
|
|
|
|
|
|
return window->SetAudioVolume(aVolume);
|
|
|
|
}
|