зеркало из https://github.com/mozilla/gecko-dev.git
3308 строки
110 KiB
C++
3308 строки
110 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/TextEventDispatcher.h"
|
|
#include "mozilla/TextEventDispatcherListener.h"
|
|
|
|
#include "mozilla/layers/CompositorBridgeChild.h"
|
|
#include "mozilla/layers/CompositorBridgeParent.h"
|
|
#include "mozilla/layers/ImageBridgeChild.h"
|
|
#include "nsBaseWidget.h"
|
|
#include "nsDeviceContext.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsGfxCIID.h"
|
|
#include "nsWidgetsCID.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsIKeyEventInPluginCallback.h"
|
|
#include "nsIScreenManager.h"
|
|
#include "nsAppDirectoryServiceDefs.h"
|
|
#include "nsISimpleEnumerator.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "BasicLayers.h"
|
|
#include "ClientLayerManager.h"
|
|
#include "mozilla/layers/Compositor.h"
|
|
#include "nsIXULRuntime.h"
|
|
#include "nsIXULWindow.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsXULPopupManager.h"
|
|
#include "nsIWidgetListener.h"
|
|
#include "nsIGfxInfo.h"
|
|
#include "npapi.h"
|
|
#include "X11UndefineNone.h"
|
|
#include "base/thread.h"
|
|
#include "prdtoa.h"
|
|
#include "prenv.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "nsContentUtils.h"
|
|
#include "gfxPrefs.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "GLConsts.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/IMEStateManager.h"
|
|
#include "mozilla/VsyncDispatcher.h"
|
|
#include "mozilla/layers/IAPZCTreeManager.h"
|
|
#include "mozilla/layers/APZEventState.h"
|
|
#include "mozilla/layers/APZThreadUtils.h"
|
|
#include "mozilla/layers/ChromeProcessController.h"
|
|
#include "mozilla/layers/InputAPZContext.h"
|
|
#include "mozilla/layers/APZCCallbackHelper.h"
|
|
#include "mozilla/dom/ContentChild.h"
|
|
#include "mozilla/dom/TabParent.h"
|
|
#include "mozilla/gfx/GPUProcessManager.h"
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/Sprintf.h"
|
|
#include "nsRefPtrHashtable.h"
|
|
#include "TouchEvents.h"
|
|
#include "WritingModes.h"
|
|
#include "InputData.h"
|
|
#include "FrameLayerBuilder.h"
|
|
#ifdef ACCESSIBILITY
|
|
#include "nsAccessibilityService.h"
|
|
#endif
|
|
#include "gfxConfig.h"
|
|
#include "mozilla/layers/CompositorSession.h"
|
|
#include "VRManagerChild.h"
|
|
|
|
#ifdef DEBUG
|
|
#include "nsIObserver.h"
|
|
|
|
static void debug_RegisterPrefCallbacks();
|
|
|
|
#endif
|
|
|
|
#ifdef NOISY_WIDGET_LEAKS
|
|
static int32_t gNumWidgets;
|
|
#endif
|
|
|
|
#ifdef XP_MACOSX
|
|
#include "nsCocoaFeatures.h"
|
|
#endif
|
|
|
|
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
|
|
static nsRefPtrHashtable<nsVoidPtrHashKey, nsIWidget>* sPluginWidgetList;
|
|
#endif
|
|
|
|
nsIRollupListener* nsBaseWidget::gRollupListener = nullptr;
|
|
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::layers;
|
|
using namespace mozilla::ipc;
|
|
using namespace mozilla::widget;
|
|
using namespace mozilla;
|
|
using base::Thread;
|
|
|
|
nsIContent* nsBaseWidget::mLastRollup = nullptr;
|
|
// Global user preference for disabling native theme. Used
|
|
// in NativeWindowTheme.
|
|
bool gDisableNativeTheme = false;
|
|
|
|
// Async pump timer during injected long touch taps
|
|
#define TOUCH_INJECT_PUMP_TIMER_MSEC 50
|
|
#define TOUCH_INJECT_LONG_TAP_DEFAULT_MSEC 1500
|
|
int32_t nsIWidget::sPointerIdCounter = 0;
|
|
|
|
// Some statics from nsIWidget.h
|
|
/*static*/ uint64_t AutoObserverNotifier::sObserverId = 0;
|
|
/*static*/ nsDataHashtable<nsUint64HashKey, nsCOMPtr<nsIObserver>> AutoObserverNotifier::sSavedObservers;
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
void
|
|
IMENotification::SelectionChangeDataBase::SetWritingMode(
|
|
const WritingMode& aWritingMode)
|
|
{
|
|
mWritingMode = aWritingMode.mWritingMode;
|
|
}
|
|
|
|
WritingMode
|
|
IMENotification::SelectionChangeDataBase::GetWritingMode() const
|
|
{
|
|
return WritingMode(mWritingMode);
|
|
}
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|
|
|
|
nsAutoRollup::nsAutoRollup()
|
|
{
|
|
// remember if mLastRollup was null, and only clear it upon destruction
|
|
// if so. This prevents recursive usage of nsAutoRollup from clearing
|
|
// mLastRollup when it shouldn't.
|
|
wasClear = !nsBaseWidget::mLastRollup;
|
|
}
|
|
|
|
nsAutoRollup::~nsAutoRollup()
|
|
{
|
|
if (nsBaseWidget::mLastRollup && wasClear) {
|
|
NS_RELEASE(nsBaseWidget::mLastRollup);
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(nsBaseWidget, nsIWidget, nsISupportsWeakReference)
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// nsBaseWidget constructor
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
nsBaseWidget::nsBaseWidget()
|
|
: mWidgetListener(nullptr)
|
|
, mAttachedWidgetListener(nullptr)
|
|
, mPreviouslyAttachedWidgetListener(nullptr)
|
|
, mLayerManager(nullptr)
|
|
, mCompositorVsyncDispatcher(nullptr)
|
|
, mCursor(eCursor_standard)
|
|
, mBorderStyle(eBorderStyle_none)
|
|
, mBounds(0,0,0,0)
|
|
, mOriginalBounds(nullptr)
|
|
, mClipRectCount(0)
|
|
, mSizeMode(nsSizeMode_Normal)
|
|
, mPopupLevel(ePopupLevelTop)
|
|
, mPopupType(ePopupTypeAny)
|
|
, mCompositorWidgetDelegate(nullptr)
|
|
, mUpdateCursor(true)
|
|
, mUseAttachedEvents(false)
|
|
, mIMEHasFocus(false)
|
|
#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
|
|
, mAccessibilityInUseFlag(false)
|
|
#endif
|
|
{
|
|
#ifdef NOISY_WIDGET_LEAKS
|
|
gNumWidgets++;
|
|
printf("WIDGETS+ = %d\n", gNumWidgets);
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
debug_RegisterPrefCallbacks();
|
|
#endif
|
|
|
|
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
|
|
if (!sPluginWidgetList) {
|
|
sPluginWidgetList = new nsRefPtrHashtable<nsVoidPtrHashKey, nsIWidget>();
|
|
}
|
|
#endif
|
|
mShutdownObserver = new WidgetShutdownObserver(this);
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(WidgetShutdownObserver, nsIObserver)
|
|
|
|
WidgetShutdownObserver::WidgetShutdownObserver(nsBaseWidget* aWidget) :
|
|
mWidget(aWidget),
|
|
mRegistered(false)
|
|
{
|
|
Register();
|
|
}
|
|
|
|
WidgetShutdownObserver::~WidgetShutdownObserver()
|
|
{
|
|
// No need to call Unregister(), we can't be destroyed until nsBaseWidget
|
|
// gets torn down. The observer service and nsBaseWidget have a ref on us
|
|
// so nsBaseWidget has to call Unregister and then clear its ref.
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
WidgetShutdownObserver::Observe(nsISupports *aSubject,
|
|
const char *aTopic,
|
|
const char16_t *aData)
|
|
{
|
|
if (mWidget && !strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
|
|
RefPtr<nsBaseWidget> widget(mWidget);
|
|
widget->Shutdown();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
WidgetShutdownObserver::Register()
|
|
{
|
|
if (!mRegistered) {
|
|
mRegistered = true;
|
|
nsContentUtils::RegisterShutdownObserver(this);
|
|
}
|
|
}
|
|
|
|
void
|
|
WidgetShutdownObserver::Unregister()
|
|
{
|
|
if (mRegistered) {
|
|
mWidget = nullptr;
|
|
nsContentUtils::UnregisterShutdownObserver(this);
|
|
mRegistered = false;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::Shutdown()
|
|
{
|
|
DestroyCompositor();
|
|
FreeShutdownObserver();
|
|
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
|
|
if (sPluginWidgetList) {
|
|
delete sPluginWidgetList;
|
|
sPluginWidgetList = nullptr;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void nsBaseWidget::DestroyCompositor()
|
|
{
|
|
// We release this before releasing the compositor, since it may hold the
|
|
// last reference to our ClientLayerManager. ClientLayerManager's dtor can
|
|
// trigger a paint, creating a new compositor, and we don't want to re-use
|
|
// the old vsync dispatcher.
|
|
if (mCompositorVsyncDispatcher) {
|
|
mCompositorVsyncDispatcher->Shutdown();
|
|
mCompositorVsyncDispatcher = nullptr;
|
|
}
|
|
|
|
// The compositor shutdown sequence looks like this:
|
|
// 1. CompositorSession calls CompositorBridgeChild::Destroy.
|
|
// 2. CompositorBridgeChild synchronously sends WillClose.
|
|
// 3. CompositorBridgeParent releases some resources (such as the layer
|
|
// manager, compositor, and widget).
|
|
// 4. CompositorBridgeChild::Destroy returns.
|
|
// 5. Asynchronously, CompositorBridgeParent::ActorDestroy will fire on the
|
|
// compositor thread when the I/O thread closes the IPC channel.
|
|
// 6. Step 5 will schedule DeferredDestroy on the compositor thread, which
|
|
// releases the reference CompositorBridgeParent holds to itself.
|
|
//
|
|
// When CompositorSession::Shutdown returns, we assume the compositor is gone
|
|
// or will be gone very soon.
|
|
if (mCompositorSession) {
|
|
ReleaseContentController();
|
|
mAPZC = nullptr;
|
|
mCompositorWidgetDelegate = nullptr;
|
|
mCompositorBridgeChild = nullptr;
|
|
|
|
// XXX CompositorBridgeChild and CompositorBridgeParent might be re-created in
|
|
// ClientLayerManager destructor. See bug 1133426.
|
|
RefPtr<CompositorSession> session = mCompositorSession.forget();
|
|
session->Shutdown();
|
|
}
|
|
}
|
|
|
|
void nsBaseWidget::ReleaseContentController()
|
|
{
|
|
if (mRootContentController) {
|
|
mRootContentController->Destroy();
|
|
mRootContentController = nullptr;
|
|
}
|
|
}
|
|
|
|
void nsBaseWidget::DestroyLayerManager()
|
|
{
|
|
if (mLayerManager) {
|
|
mLayerManager->Destroy();
|
|
mLayerManager = nullptr;
|
|
}
|
|
DestroyCompositor();
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::OnRenderingDeviceReset(uint64_t aSeqNo)
|
|
{
|
|
if (!mLayerManager || !mCompositorSession) {
|
|
return;
|
|
}
|
|
|
|
nsTArray<LayersBackend> backendHints;
|
|
gfxPlatform::GetPlatform()->GetCompositorBackends(ComputeShouldAccelerate(), backendHints);
|
|
|
|
// If the existing compositor does not use acceleration, and this widget
|
|
// should not be accelerated, then there's no point in resetting.
|
|
//
|
|
// Note that if this widget should be accelerated, but instead has a basic
|
|
// compositor, we still reset just in case we're now in the position to get
|
|
// accelerated layers again.
|
|
RefPtr<ClientLayerManager> clm = mLayerManager->AsClientLayerManager();
|
|
if (!ComputeShouldAccelerate() &&
|
|
clm->GetTextureFactoryIdentifier().mParentBackend != LayersBackend::LAYERS_BASIC)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Recreate the compositor.
|
|
TextureFactoryIdentifier identifier;
|
|
if (!mCompositorSession->Reset(backendHints, aSeqNo, &identifier)) {
|
|
// No action was taken, so we don't have to do anything.
|
|
return;
|
|
}
|
|
|
|
// Invalidate all layers.
|
|
FrameLayerBuilder::InvalidateAllLayers(mLayerManager);
|
|
|
|
// Update the texture factory identifier.
|
|
clm->UpdateTextureFactoryIdentifier(identifier);
|
|
ImageBridgeChild::IdentifyCompositorTextureHost(identifier);
|
|
gfx::VRManagerChild::IdentifyTextureHost(identifier);
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::FreeShutdownObserver()
|
|
{
|
|
if (mShutdownObserver) {
|
|
mShutdownObserver->Unregister();
|
|
}
|
|
mShutdownObserver = nullptr;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// nsBaseWidget destructor
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
nsBaseWidget::~nsBaseWidget()
|
|
{
|
|
IMEStateManager::WidgetDestroyed(this);
|
|
|
|
if (mLayerManager) {
|
|
if (BasicLayerManager* mgr = mLayerManager->AsBasicLayerManager()) {
|
|
mgr->ClearRetainerWidget();
|
|
}
|
|
}
|
|
|
|
FreeShutdownObserver();
|
|
DestroyLayerManager();
|
|
|
|
#ifdef NOISY_WIDGET_LEAKS
|
|
gNumWidgets--;
|
|
printf("WIDGETS- = %d\n", gNumWidgets);
|
|
#endif
|
|
|
|
delete mOriginalBounds;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Basic create.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void nsBaseWidget::BaseCreate(nsIWidget* aParent,
|
|
nsWidgetInitData* aInitData)
|
|
{
|
|
static bool gDisableNativeThemeCached = false;
|
|
if (!gDisableNativeThemeCached) {
|
|
Preferences::AddBoolVarCache(&gDisableNativeTheme,
|
|
"mozilla.widget.disable-native-theme",
|
|
gDisableNativeTheme);
|
|
gDisableNativeThemeCached = true;
|
|
}
|
|
|
|
// keep a reference to the device context
|
|
if (nullptr != aInitData) {
|
|
mWindowType = aInitData->mWindowType;
|
|
mBorderStyle = aInitData->mBorderStyle;
|
|
mPopupLevel = aInitData->mPopupLevel;
|
|
mPopupType = aInitData->mPopupHint;
|
|
}
|
|
|
|
if (aParent) {
|
|
aParent->AddChild(this);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Accessor functions to get/set the client data
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
nsIWidgetListener* nsBaseWidget::GetWidgetListener()
|
|
{
|
|
return mWidgetListener;
|
|
}
|
|
|
|
void nsBaseWidget::SetWidgetListener(nsIWidgetListener* aWidgetListener)
|
|
{
|
|
mWidgetListener = aWidgetListener;
|
|
}
|
|
|
|
already_AddRefed<nsIWidget>
|
|
nsBaseWidget::CreateChild(const LayoutDeviceIntRect& aRect,
|
|
nsWidgetInitData* aInitData,
|
|
bool aForceUseIWidgetParent)
|
|
{
|
|
nsIWidget* parent = this;
|
|
nsNativeWidget nativeParent = nullptr;
|
|
|
|
if (!aForceUseIWidgetParent) {
|
|
// Use only either parent or nativeParent, not both, to match
|
|
// existing code. Eventually Create() should be divested of its
|
|
// nativeWidget parameter.
|
|
nativeParent = parent ? parent->GetNativeData(NS_NATIVE_WIDGET) : nullptr;
|
|
parent = nativeParent ? nullptr : parent;
|
|
MOZ_ASSERT(!parent || !nativeParent, "messed up logic");
|
|
}
|
|
|
|
nsCOMPtr<nsIWidget> widget;
|
|
if (aInitData && aInitData->mWindowType == eWindowType_popup) {
|
|
widget = AllocateChildPopupWidget();
|
|
} else {
|
|
static NS_DEFINE_IID(kCChildCID, NS_CHILD_CID);
|
|
widget = do_CreateInstance(kCChildCID);
|
|
}
|
|
|
|
if (widget &&
|
|
NS_SUCCEEDED(widget->Create(parent, nativeParent, aRect, aInitData))) {
|
|
return widget.forget();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// Attach a view to our widget which we'll send events to.
|
|
void
|
|
nsBaseWidget::AttachViewToTopLevel(bool aUseAttachedEvents)
|
|
{
|
|
NS_ASSERTION((mWindowType == eWindowType_toplevel ||
|
|
mWindowType == eWindowType_dialog ||
|
|
mWindowType == eWindowType_invisible ||
|
|
mWindowType == eWindowType_child),
|
|
"Can't attach to window of that type");
|
|
|
|
mUseAttachedEvents = aUseAttachedEvents;
|
|
}
|
|
|
|
nsIWidgetListener* nsBaseWidget::GetAttachedWidgetListener()
|
|
{
|
|
return mAttachedWidgetListener;
|
|
}
|
|
|
|
nsIWidgetListener* nsBaseWidget::GetPreviouslyAttachedWidgetListener()
|
|
{
|
|
return mPreviouslyAttachedWidgetListener;
|
|
}
|
|
|
|
void nsBaseWidget::SetPreviouslyAttachedWidgetListener(nsIWidgetListener* aListener)
|
|
{
|
|
mPreviouslyAttachedWidgetListener = aListener;
|
|
}
|
|
|
|
void nsBaseWidget::SetAttachedWidgetListener(nsIWidgetListener* aListener)
|
|
{
|
|
mAttachedWidgetListener = aListener;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Close this nsBaseWidget
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void nsBaseWidget::Destroy()
|
|
{
|
|
// Just in case our parent is the only ref to us
|
|
nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
|
|
// disconnect from the parent
|
|
nsIWidget *parent = GetParent();
|
|
if (parent) {
|
|
parent->RemoveChild(this);
|
|
}
|
|
|
|
#if defined(XP_WIN)
|
|
// Allow our scroll capture container to be cleaned up, if we have one.
|
|
mScrollCaptureContainer = nullptr;
|
|
#endif
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Set this nsBaseWidget's parent
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
NS_IMETHODIMP nsBaseWidget::SetParent(nsIWidget* aNewParent)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Get this nsBaseWidget parent
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
nsIWidget* nsBaseWidget::GetParent(void)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Get this nsBaseWidget top level widget
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
nsIWidget* nsBaseWidget::GetTopLevelWidget()
|
|
{
|
|
nsIWidget *topLevelWidget = nullptr, *widget = this;
|
|
while (widget) {
|
|
topLevelWidget = widget;
|
|
widget = widget->GetParent();
|
|
}
|
|
return topLevelWidget;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Get this nsBaseWidget's top (non-sheet) parent (if it's a sheet)
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
nsIWidget* nsBaseWidget::GetSheetWindowParent(void)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
float nsBaseWidget::GetDPI()
|
|
{
|
|
return 96.0f;
|
|
}
|
|
|
|
CSSToLayoutDeviceScale nsIWidget::GetDefaultScale()
|
|
{
|
|
double devPixelsPerCSSPixel = DefaultScaleOverride();
|
|
|
|
if (devPixelsPerCSSPixel <= 0.0) {
|
|
devPixelsPerCSSPixel = GetDefaultScaleInternal();
|
|
}
|
|
|
|
return CSSToLayoutDeviceScale(devPixelsPerCSSPixel);
|
|
}
|
|
|
|
/* static */
|
|
double nsIWidget::DefaultScaleOverride()
|
|
{
|
|
// The number of device pixels per CSS pixel. A value <= 0 means choose
|
|
// automatically based on the DPI. A positive value is used as-is. This effectively
|
|
// controls the size of a CSS "px".
|
|
double devPixelsPerCSSPixel = -1.0;
|
|
|
|
nsAdoptingCString prefString = Preferences::GetCString("layout.css.devPixelsPerPx");
|
|
if (!prefString.IsEmpty()) {
|
|
devPixelsPerCSSPixel = PR_strtod(prefString, nullptr);
|
|
}
|
|
|
|
return devPixelsPerCSSPixel;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Add a child to the list of children
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void nsBaseWidget::AddChild(nsIWidget* aChild)
|
|
{
|
|
MOZ_ASSERT(!aChild->GetNextSibling() && !aChild->GetPrevSibling(),
|
|
"aChild not properly removed from its old child list");
|
|
|
|
if (!mFirstChild) {
|
|
mFirstChild = mLastChild = aChild;
|
|
} else {
|
|
// append to the list
|
|
MOZ_ASSERT(mLastChild);
|
|
MOZ_ASSERT(!mLastChild->GetNextSibling());
|
|
mLastChild->SetNextSibling(aChild);
|
|
aChild->SetPrevSibling(mLastChild);
|
|
mLastChild = aChild;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Remove a child from the list of children
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void nsBaseWidget::RemoveChild(nsIWidget* aChild)
|
|
{
|
|
#ifdef DEBUG
|
|
#ifdef XP_MACOSX
|
|
// nsCocoaWindow doesn't implement GetParent, so in that case parent will be
|
|
// null and we'll just have to do without this assertion.
|
|
nsIWidget* parent = aChild->GetParent();
|
|
NS_ASSERTION(!parent || parent == this, "Not one of our kids!");
|
|
#else
|
|
MOZ_RELEASE_ASSERT(aChild->GetParent() == this, "Not one of our kids!");
|
|
#endif
|
|
#endif
|
|
|
|
if (mLastChild == aChild) {
|
|
mLastChild = mLastChild->GetPrevSibling();
|
|
}
|
|
if (mFirstChild == aChild) {
|
|
mFirstChild = mFirstChild->GetNextSibling();
|
|
}
|
|
|
|
// Now remove from the list. Make sure that we pass ownership of the tail
|
|
// of the list correctly before we have aChild let go of it.
|
|
nsIWidget* prev = aChild->GetPrevSibling();
|
|
nsIWidget* next = aChild->GetNextSibling();
|
|
if (prev) {
|
|
prev->SetNextSibling(next);
|
|
}
|
|
if (next) {
|
|
next->SetPrevSibling(prev);
|
|
}
|
|
|
|
aChild->SetNextSibling(nullptr);
|
|
aChild->SetPrevSibling(nullptr);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Sets widget's position within its parent's child list.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void nsBaseWidget::SetZIndex(int32_t aZIndex)
|
|
{
|
|
// Hold a ref to ourselves just in case, since we're going to remove
|
|
// from our parent.
|
|
nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
|
|
|
|
mZIndex = aZIndex;
|
|
|
|
// reorder this child in its parent's list.
|
|
nsBaseWidget* parent = static_cast<nsBaseWidget*>(GetParent());
|
|
if (parent) {
|
|
parent->RemoveChild(this);
|
|
// Scope sib outside the for loop so we can check it afterward
|
|
nsIWidget* sib = parent->GetFirstChild();
|
|
for ( ; sib; sib = sib->GetNextSibling()) {
|
|
int32_t childZIndex = GetZIndex();
|
|
if (aZIndex < childZIndex) {
|
|
// Insert ourselves before sib
|
|
nsIWidget* prev = sib->GetPrevSibling();
|
|
mNextSibling = sib;
|
|
mPrevSibling = prev;
|
|
sib->SetPrevSibling(this);
|
|
if (prev) {
|
|
prev->SetNextSibling(this);
|
|
} else {
|
|
NS_ASSERTION(sib == parent->mFirstChild, "Broken child list");
|
|
// We've taken ownership of sib, so it's safe to have parent let
|
|
// go of it
|
|
parent->mFirstChild = this;
|
|
}
|
|
PlaceBehind(eZPlacementBelow, sib, false);
|
|
break;
|
|
}
|
|
}
|
|
// were we added to the list?
|
|
if (!sib) {
|
|
parent->AddChild(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Maximize, minimize or restore the window. The BaseWidget implementation
|
|
// merely stores the state.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void
|
|
nsBaseWidget::SetSizeMode(nsSizeMode aMode)
|
|
{
|
|
MOZ_ASSERT(aMode == nsSizeMode_Normal ||
|
|
aMode == nsSizeMode_Minimized ||
|
|
aMode == nsSizeMode_Maximized ||
|
|
aMode == nsSizeMode_Fullscreen);
|
|
mSizeMode = aMode;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Get this component cursor
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
nsCursor nsBaseWidget::GetCursor()
|
|
{
|
|
return mCursor;
|
|
}
|
|
|
|
NS_IMETHODIMP nsBaseWidget::SetCursor(nsCursor aCursor)
|
|
{
|
|
mCursor = aCursor;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsBaseWidget::SetCursor(imgIContainer* aCursor,
|
|
uint32_t aHotspotX, uint32_t aHotspotY)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Window transparency methods
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
void nsBaseWidget::SetTransparencyMode(nsTransparencyMode aMode) {
|
|
}
|
|
|
|
nsTransparencyMode nsBaseWidget::GetTransparencyMode() {
|
|
return eTransparencyOpaque;
|
|
}
|
|
|
|
bool
|
|
nsBaseWidget::IsWindowClipRegionEqual(const nsTArray<LayoutDeviceIntRect>& aRects)
|
|
{
|
|
return mClipRects &&
|
|
mClipRectCount == aRects.Length() &&
|
|
memcmp(mClipRects.get(), aRects.Elements(), sizeof(LayoutDeviceIntRect)*mClipRectCount) == 0;
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::StoreWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects)
|
|
{
|
|
mClipRectCount = aRects.Length();
|
|
mClipRects = MakeUnique<LayoutDeviceIntRect[]>(mClipRectCount);
|
|
if (mClipRects) {
|
|
memcpy(mClipRects.get(), aRects.Elements(), sizeof(LayoutDeviceIntRect)*mClipRectCount);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::GetWindowClipRegion(nsTArray<LayoutDeviceIntRect>* aRects)
|
|
{
|
|
if (mClipRects) {
|
|
aRects->AppendElements(mClipRects.get(), mClipRectCount);
|
|
} else {
|
|
aRects->AppendElement(LayoutDeviceIntRect(0, 0, mBounds.width, mBounds.height));
|
|
}
|
|
}
|
|
|
|
const LayoutDeviceIntRegion
|
|
nsBaseWidget::RegionFromArray(const nsTArray<LayoutDeviceIntRect>& aRects)
|
|
{
|
|
LayoutDeviceIntRegion region;
|
|
for (uint32_t i = 0; i < aRects.Length(); ++i) {
|
|
region.Or(region, aRects[i]);
|
|
}
|
|
return region;
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::ArrayFromRegion(const LayoutDeviceIntRegion& aRegion,
|
|
nsTArray<LayoutDeviceIntRect>& aRects)
|
|
{
|
|
for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
|
|
aRects.AppendElement(iter.Get());
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsBaseWidget::SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,
|
|
bool aIntersectWithExisting)
|
|
{
|
|
if (!aIntersectWithExisting) {
|
|
StoreWindowClipRegion(aRects);
|
|
} else {
|
|
// get current rects
|
|
nsTArray<LayoutDeviceIntRect> currentRects;
|
|
GetWindowClipRegion(¤tRects);
|
|
// create region from them
|
|
LayoutDeviceIntRegion currentRegion = RegionFromArray(currentRects);
|
|
// create region from new rects
|
|
LayoutDeviceIntRegion newRegion = RegionFromArray(aRects);
|
|
// intersect regions
|
|
LayoutDeviceIntRegion intersection;
|
|
intersection.And(currentRegion, newRegion);
|
|
// create int rect array from intersection
|
|
nsTArray<LayoutDeviceIntRect> rects;
|
|
ArrayFromRegion(intersection, rects);
|
|
// store
|
|
StoreWindowClipRegion(rects);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Hide window borders/decorations for this widget
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
NS_IMETHODIMP nsBaseWidget::HideWindowChrome(bool aShouldHide)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* virtual */ void
|
|
nsBaseWidget::PerformFullscreenTransition(FullscreenTransitionStage aStage,
|
|
uint16_t aDuration,
|
|
nsISupports* aData,
|
|
nsIRunnable* aCallback)
|
|
{
|
|
MOZ_ASSERT_UNREACHABLE(
|
|
"Should never call PerformFullscreenTransition on nsBaseWidget");
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Put the window into full-screen mode
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void
|
|
nsBaseWidget::InfallibleMakeFullScreen(bool aFullScreen, nsIScreen* aScreen)
|
|
{
|
|
HideWindowChrome(aFullScreen);
|
|
|
|
if (aFullScreen) {
|
|
if (!mOriginalBounds) {
|
|
mOriginalBounds = new LayoutDeviceIntRect();
|
|
}
|
|
*mOriginalBounds = GetScreenBounds();
|
|
|
|
// Move to top-left corner of screen and size to the screen dimensions
|
|
nsCOMPtr<nsIScreen> screen = aScreen;
|
|
if (!screen) {
|
|
screen = GetWidgetScreen();
|
|
}
|
|
if (screen) {
|
|
int32_t left, top, width, height;
|
|
if (NS_SUCCEEDED(screen->GetRectDisplayPix(&left, &top, &width, &height))) {
|
|
Resize(left, top, width, height, true);
|
|
}
|
|
}
|
|
} else if (mOriginalBounds) {
|
|
if (BoundsUseDesktopPixels()) {
|
|
DesktopRect deskRect = *mOriginalBounds / GetDesktopToDeviceScale();
|
|
Resize(deskRect.x, deskRect.y, deskRect.width, deskRect.height, true);
|
|
} else {
|
|
Resize(mOriginalBounds->x, mOriginalBounds->y, mOriginalBounds->width,
|
|
mOriginalBounds->height, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsBaseWidget::MakeFullScreen(bool aFullScreen, nsIScreen* aScreen)
|
|
{
|
|
InfallibleMakeFullScreen(aFullScreen, aScreen);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
|
|
nsBaseWidget* aWidget, gfxContext* aTarget,
|
|
BufferMode aDoubleBuffering, ScreenRotation aRotation)
|
|
: mWidget(aWidget)
|
|
{
|
|
LayerManager* lm = mWidget->GetLayerManager();
|
|
NS_ASSERTION(!lm || lm->GetBackendType() == LayersBackend::LAYERS_BASIC,
|
|
"AutoLayerManagerSetup instantiated for non-basic layer backend!");
|
|
if (lm) {
|
|
mLayerManager = lm->AsBasicLayerManager();
|
|
if (mLayerManager) {
|
|
mLayerManager->SetDefaultTarget(aTarget);
|
|
mLayerManager->SetDefaultTargetConfiguration(aDoubleBuffering, aRotation);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsBaseWidget::AutoLayerManagerSetup::~AutoLayerManagerSetup()
|
|
{
|
|
if (mLayerManager) {
|
|
mLayerManager->SetDefaultTarget(nullptr);
|
|
mLayerManager->SetDefaultTargetConfiguration(mozilla::layers::BufferMode::BUFFER_NONE, ROTATION_0);
|
|
}
|
|
}
|
|
|
|
bool nsBaseWidget::IsSmallPopup() const
|
|
{
|
|
return mWindowType == eWindowType_popup && mPopupType != ePopupTypePanel;
|
|
}
|
|
|
|
bool
|
|
nsBaseWidget::ComputeShouldAccelerate()
|
|
{
|
|
return gfx::gfxConfig::IsEnabled(gfx::Feature::HW_COMPOSITING) &&
|
|
WidgetTypeSupportsAcceleration();
|
|
}
|
|
|
|
bool
|
|
nsBaseWidget::UseAPZ()
|
|
{
|
|
return (gfxPlatform::AsyncPanZoomEnabled() &&
|
|
(WindowType() == eWindowType_toplevel || WindowType() == eWindowType_child));
|
|
}
|
|
|
|
void nsBaseWidget::CreateCompositor()
|
|
{
|
|
LayoutDeviceIntRect rect = GetBounds();
|
|
CreateCompositor(rect.width, rect.height);
|
|
}
|
|
|
|
already_AddRefed<GeckoContentController>
|
|
nsBaseWidget::CreateRootContentController()
|
|
{
|
|
RefPtr<GeckoContentController> controller = new ChromeProcessController(this, mAPZEventState, mAPZC);
|
|
return controller.forget();
|
|
}
|
|
|
|
void nsBaseWidget::ConfigureAPZCTreeManager()
|
|
{
|
|
MOZ_ASSERT(mAPZC);
|
|
|
|
ConfigureAPZControllerThread();
|
|
|
|
mAPZC->SetDPI(GetDPI());
|
|
|
|
RefPtr<IAPZCTreeManager> treeManager = mAPZC; // for capture by the lambdas
|
|
|
|
ContentReceivedInputBlockCallback callback(
|
|
[treeManager](const ScrollableLayerGuid& aGuid,
|
|
uint64_t aInputBlockId,
|
|
bool aPreventDefault)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
APZThreadUtils::RunOnControllerThread(NewRunnableMethod
|
|
<uint64_t, bool>(treeManager,
|
|
&IAPZCTreeManager::ContentReceivedInputBlock,
|
|
aInputBlockId,
|
|
aPreventDefault));
|
|
});
|
|
mAPZEventState = new APZEventState(this, mozilla::Move(callback));
|
|
|
|
mSetAllowedTouchBehaviorCallback = [treeManager](uint64_t aInputBlockId,
|
|
const nsTArray<TouchBehaviorFlags>& aFlags)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
APZThreadUtils::RunOnControllerThread(NewRunnableMethod
|
|
<uint64_t,
|
|
StoreCopyPassByLRef<nsTArray<TouchBehaviorFlags>>>(treeManager,
|
|
&IAPZCTreeManager::SetAllowedTouchBehavior,
|
|
aInputBlockId, aFlags));
|
|
};
|
|
|
|
mRootContentController = CreateRootContentController();
|
|
if (mRootContentController) {
|
|
mCompositorSession->SetContentController(mRootContentController);
|
|
}
|
|
|
|
// When APZ is enabled, we can actually enable raw touch events because we
|
|
// have code that can deal with them properly. If APZ is not enabled, this
|
|
// function doesn't get called.
|
|
if (Preferences::GetInt("dom.w3c_touch_events.enabled", 0) ||
|
|
Preferences::GetBool("dom.w3c_pointer_events.enabled", false)) {
|
|
RegisterTouchWindow();
|
|
}
|
|
}
|
|
|
|
void nsBaseWidget::ConfigureAPZControllerThread()
|
|
{
|
|
// By default the controller thread is the main thread.
|
|
APZThreadUtils::SetControllerThread(MessageLoop::current());
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::SetConfirmedTargetAPZC(uint64_t aInputBlockId,
|
|
const nsTArray<ScrollableLayerGuid>& aTargets) const
|
|
{
|
|
APZThreadUtils::RunOnControllerThread(NewRunnableMethod
|
|
<uint64_t, StoreCopyPassByRRef<nsTArray<ScrollableLayerGuid>>>(mAPZC,
|
|
&IAPZCTreeManager::SetTargetAPZC,
|
|
aInputBlockId, aTargets));
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::UpdateZoomConstraints(const uint32_t& aPresShellId,
|
|
const FrameMetrics::ViewID& aViewId,
|
|
const Maybe<ZoomConstraints>& aConstraints)
|
|
{
|
|
if (!mCompositorSession || !mAPZC) {
|
|
if (mInitialZoomConstraints) {
|
|
MOZ_ASSERT(mInitialZoomConstraints->mPresShellID == aPresShellId);
|
|
MOZ_ASSERT(mInitialZoomConstraints->mViewID == aViewId);
|
|
if (!aConstraints) {
|
|
mInitialZoomConstraints.reset();
|
|
}
|
|
}
|
|
|
|
if (aConstraints) {
|
|
// We have some constraints, but the compositor and APZC aren't created yet.
|
|
// Save these so we can use them later.
|
|
mInitialZoomConstraints = Some(InitialZoomConstraints(aPresShellId, aViewId, aConstraints.ref()));
|
|
}
|
|
return;
|
|
}
|
|
uint64_t layersId = mCompositorSession->RootLayerTreeId();
|
|
mAPZC->UpdateZoomConstraints(ScrollableLayerGuid(layersId, aPresShellId, aViewId),
|
|
aConstraints);
|
|
}
|
|
|
|
bool
|
|
nsBaseWidget::AsyncPanZoomEnabled() const
|
|
{
|
|
return !!mAPZC;
|
|
}
|
|
|
|
nsEventStatus
|
|
nsBaseWidget::ProcessUntransformedAPZEvent(WidgetInputEvent* aEvent,
|
|
const ScrollableLayerGuid& aGuid,
|
|
uint64_t aInputBlockId,
|
|
nsEventStatus aApzResponse)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
InputAPZContext context(aGuid, aInputBlockId, aApzResponse);
|
|
|
|
// If this is an event that the APZ has targeted to an APZC in the root
|
|
// process, apply that APZC's callback-transform before dispatching the
|
|
// event. If the event is instead targeted to an APZC in the child process,
|
|
// the transform will be applied in the child process before dispatching
|
|
// the event there (see e.g. TabChild::RecvRealTouchEvent()).
|
|
if (aGuid.mLayersId == mCompositorSession->RootLayerTreeId()) {
|
|
APZCCallbackHelper::ApplyCallbackTransform(*aEvent, aGuid,
|
|
GetDefaultScale());
|
|
}
|
|
|
|
// Make a copy of the original event for the APZCCallbackHelper helpers that
|
|
// we call later, because the event passed to DispatchEvent can get mutated in
|
|
// ways that we don't want (i.e. touch points can get stripped out).
|
|
nsEventStatus status;
|
|
UniquePtr<WidgetEvent> original(aEvent->Duplicate());
|
|
DispatchEvent(aEvent, status);
|
|
|
|
if (mAPZC && !context.WasRoutedToChildProcess() && aInputBlockId) {
|
|
// EventStateManager did not route the event into the child process.
|
|
// It's safe to communicate to APZ that the event has been processed.
|
|
// TODO: Eventually we'll be able to move the SendSetTargetAPZCNotification
|
|
// call into APZEventState::Process*Event() as well.
|
|
if (WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent()) {
|
|
if (touchEvent->mMessage == eTouchStart) {
|
|
if (gfxPrefs::TouchActionEnabled()) {
|
|
APZCCallbackHelper::SendSetAllowedTouchBehaviorNotification(this,
|
|
GetDocument(), *(original->AsTouchEvent()), aInputBlockId,
|
|
mSetAllowedTouchBehaviorCallback);
|
|
}
|
|
APZCCallbackHelper::SendSetTargetAPZCNotification(this, GetDocument(),
|
|
*(original->AsTouchEvent()), aGuid, aInputBlockId);
|
|
}
|
|
mAPZEventState->ProcessTouchEvent(*touchEvent, aGuid, aInputBlockId,
|
|
aApzResponse, status);
|
|
} else if (WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent()) {
|
|
MOZ_ASSERT(wheelEvent->mFlags.mHandledByAPZ);
|
|
APZCCallbackHelper::SendSetTargetAPZCNotification(this, GetDocument(),
|
|
*(original->AsWheelEvent()), aGuid, aInputBlockId);
|
|
if (wheelEvent->mCanTriggerSwipe) {
|
|
ReportSwipeStarted(aInputBlockId, wheelEvent->TriggersSwipe());
|
|
}
|
|
mAPZEventState->ProcessWheelEvent(*wheelEvent, aGuid, aInputBlockId);
|
|
} else if (WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent()) {
|
|
MOZ_ASSERT(mouseEvent->mFlags.mHandledByAPZ);
|
|
APZCCallbackHelper::SendSetTargetAPZCNotification(this, GetDocument(),
|
|
*(original->AsMouseEvent()), aGuid, aInputBlockId);
|
|
mAPZEventState->ProcessMouseEvent(*mouseEvent, aGuid, aInputBlockId);
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
class DispatchWheelEventOnMainThread : public Runnable
|
|
{
|
|
public:
|
|
DispatchWheelEventOnMainThread(const ScrollWheelInput& aWheelInput,
|
|
nsBaseWidget* aWidget,
|
|
nsEventStatus aAPZResult,
|
|
uint64_t aInputBlockId,
|
|
ScrollableLayerGuid aGuid)
|
|
: mWheelInput(aWheelInput)
|
|
, mWidget(aWidget)
|
|
, mAPZResult(aAPZResult)
|
|
, mInputBlockId(aInputBlockId)
|
|
, mGuid(aGuid)
|
|
{
|
|
}
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
WidgetWheelEvent wheelEvent = mWheelInput.ToWidgetWheelEvent(mWidget);
|
|
mWidget->ProcessUntransformedAPZEvent(&wheelEvent, mGuid, mInputBlockId, mAPZResult);
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
ScrollWheelInput mWheelInput;
|
|
nsBaseWidget* mWidget;
|
|
nsEventStatus mAPZResult;
|
|
uint64_t mInputBlockId;
|
|
ScrollableLayerGuid mGuid;
|
|
};
|
|
|
|
class DispatchWheelInputOnControllerThread : public Runnable
|
|
{
|
|
public:
|
|
DispatchWheelInputOnControllerThread(const WidgetWheelEvent& aWheelEvent,
|
|
IAPZCTreeManager* aAPZC,
|
|
nsBaseWidget* aWidget)
|
|
: mMainMessageLoop(MessageLoop::current())
|
|
, mWheelInput(aWheelEvent)
|
|
, mAPZC(aAPZC)
|
|
, mWidget(aWidget)
|
|
, mInputBlockId(0)
|
|
{
|
|
}
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
nsEventStatus result = mAPZC->ReceiveInputEvent(mWheelInput, &mGuid, &mInputBlockId);
|
|
if (result == nsEventStatus_eConsumeNoDefault) {
|
|
return NS_OK;
|
|
}
|
|
RefPtr<Runnable> r = new DispatchWheelEventOnMainThread(mWheelInput, mWidget, result, mInputBlockId, mGuid);
|
|
mMainMessageLoop->PostTask(r.forget());
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
MessageLoop* mMainMessageLoop;
|
|
ScrollWheelInput mWheelInput;
|
|
RefPtr<IAPZCTreeManager> mAPZC;
|
|
nsBaseWidget* mWidget;
|
|
uint64_t mInputBlockId;
|
|
ScrollableLayerGuid mGuid;
|
|
};
|
|
|
|
void
|
|
nsBaseWidget::DispatchTouchInput(MultiTouchInput& aInput)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
if (mAPZC) {
|
|
MOZ_ASSERT(APZThreadUtils::IsControllerThread());
|
|
uint64_t inputBlockId = 0;
|
|
ScrollableLayerGuid guid;
|
|
|
|
nsEventStatus result = mAPZC->ReceiveInputEvent(aInput, &guid, &inputBlockId);
|
|
if (result == nsEventStatus_eConsumeNoDefault) {
|
|
return;
|
|
}
|
|
|
|
WidgetTouchEvent event = aInput.ToWidgetTouchEvent(this);
|
|
ProcessUntransformedAPZEvent(&event, guid, inputBlockId, result);
|
|
} else {
|
|
WidgetTouchEvent event = aInput.ToWidgetTouchEvent(this);
|
|
|
|
nsEventStatus status;
|
|
DispatchEvent(&event, status);
|
|
}
|
|
}
|
|
|
|
nsEventStatus
|
|
nsBaseWidget::DispatchInputEvent(WidgetInputEvent* aEvent)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
if (mAPZC) {
|
|
if (APZThreadUtils::IsControllerThread()) {
|
|
uint64_t inputBlockId = 0;
|
|
ScrollableLayerGuid guid;
|
|
|
|
nsEventStatus result = mAPZC->ReceiveInputEvent(*aEvent, &guid, &inputBlockId);
|
|
if (result == nsEventStatus_eConsumeNoDefault) {
|
|
return result;
|
|
}
|
|
return ProcessUntransformedAPZEvent(aEvent, guid, inputBlockId, result);
|
|
} else {
|
|
WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
|
|
if (wheelEvent) {
|
|
RefPtr<Runnable> r = new DispatchWheelInputOnControllerThread(*wheelEvent, mAPZC, this);
|
|
APZThreadUtils::RunOnControllerThread(r.forget());
|
|
return nsEventStatus_eConsumeDoDefault;
|
|
}
|
|
MOZ_CRASH();
|
|
}
|
|
}
|
|
|
|
nsEventStatus status;
|
|
DispatchEvent(aEvent, status);
|
|
return status;
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::DispatchEventToAPZOnly(mozilla::WidgetInputEvent* aEvent)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
if (mAPZC) {
|
|
MOZ_ASSERT(APZThreadUtils::IsControllerThread());
|
|
uint64_t inputBlockId = 0;
|
|
ScrollableLayerGuid guid;
|
|
mAPZC->ReceiveInputEvent(*aEvent, &guid, &inputBlockId);
|
|
}
|
|
}
|
|
|
|
nsIDocument*
|
|
nsBaseWidget::GetDocument() const
|
|
{
|
|
if (mWidgetListener) {
|
|
if (nsIPresShell* presShell = mWidgetListener->GetPresShell()) {
|
|
return presShell->GetDocument();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void nsBaseWidget::CreateCompositorVsyncDispatcher()
|
|
{
|
|
// Parent directly listens to the vsync source whereas
|
|
// child process communicate via IPC
|
|
// Should be called AFTER gfxPlatform is initialized
|
|
if (XRE_IsParentProcess()) {
|
|
mCompositorVsyncDispatcher = new CompositorVsyncDispatcher();
|
|
}
|
|
}
|
|
|
|
CompositorVsyncDispatcher*
|
|
nsBaseWidget::GetCompositorVsyncDispatcher()
|
|
{
|
|
return mCompositorVsyncDispatcher;
|
|
}
|
|
|
|
void nsBaseWidget::CreateCompositor(int aWidth, int aHeight)
|
|
{
|
|
// This makes sure that gfxPlatforms gets initialized if it hasn't by now.
|
|
gfxPlatform::GetPlatform();
|
|
|
|
MOZ_ASSERT(gfxPlatform::UsesOffMainThreadCompositing(),
|
|
"This function assumes OMTC");
|
|
|
|
MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild,
|
|
"Should have properly cleaned up the previous PCompositor pair beforehand");
|
|
|
|
if (mCompositorBridgeChild) {
|
|
mCompositorBridgeChild->Destroy();
|
|
}
|
|
|
|
// Recreating this is tricky, as we may still have an old and we need
|
|
// to make sure it's properly destroyed by calling DestroyCompositor!
|
|
|
|
// If we've already received a shutdown notification, don't try
|
|
// create a new compositor.
|
|
if (!mShutdownObserver) {
|
|
return;
|
|
}
|
|
|
|
CreateCompositorVsyncDispatcher();
|
|
|
|
RefPtr<ClientLayerManager> lm = new ClientLayerManager(this);
|
|
|
|
bool useAPZ = UseAPZ();
|
|
|
|
gfx::GPUProcessManager* gpu = gfx::GPUProcessManager::Get();
|
|
mCompositorSession = gpu->CreateTopLevelCompositor(
|
|
this,
|
|
lm,
|
|
GetDefaultScale(),
|
|
useAPZ,
|
|
UseExternalCompositingSurface(),
|
|
gfx::IntSize(aWidth, aHeight));
|
|
mCompositorBridgeChild = mCompositorSession->GetCompositorBridgeChild();
|
|
mCompositorWidgetDelegate = mCompositorSession->GetCompositorWidgetDelegate();
|
|
|
|
if (useAPZ) {
|
|
mAPZC = mCompositorSession->GetAPZCTreeManager();
|
|
ConfigureAPZCTreeManager();
|
|
} else {
|
|
mAPZC = nullptr;
|
|
}
|
|
|
|
if (mInitialZoomConstraints) {
|
|
UpdateZoomConstraints(mInitialZoomConstraints->mPresShellID,
|
|
mInitialZoomConstraints->mViewID,
|
|
Some(mInitialZoomConstraints->mConstraints));
|
|
mInitialZoomConstraints.reset();
|
|
}
|
|
|
|
ShadowLayerForwarder* lf = lm->AsShadowForwarder();
|
|
// As long as we are creating a ClientLayerManager above lf must be non-null.
|
|
MOZ_ASSERT(lf);
|
|
|
|
if (lf) {
|
|
TextureFactoryIdentifier textureFactoryIdentifier;
|
|
PLayerTransactionChild* shadowManager = nullptr;
|
|
|
|
nsTArray<LayersBackend> backendHints;
|
|
gfxPlatform::GetPlatform()->GetCompositorBackends(ComputeShouldAccelerate(), backendHints);
|
|
|
|
bool success = false;
|
|
if (!backendHints.IsEmpty()) {
|
|
shadowManager = mCompositorBridgeChild->SendPLayerTransactionConstructor(
|
|
backendHints, 0, &textureFactoryIdentifier, &success);
|
|
}
|
|
|
|
if (!success) {
|
|
NS_WARNING("Failed to create an OMT compositor.");
|
|
DestroyCompositor();
|
|
mLayerManager = nullptr;
|
|
return;
|
|
}
|
|
|
|
lf->SetShadowManager(shadowManager);
|
|
if (ClientLayerManager* clm = lm->AsClientLayerManager()) {
|
|
clm->UpdateTextureFactoryIdentifier(textureFactoryIdentifier);
|
|
}
|
|
// Some popup or transparent widgets may use a different backend than the
|
|
// compositors used with ImageBridge and VR (and more generally web content).
|
|
if (WidgetTypeSupportsAcceleration()) {
|
|
ImageBridgeChild::IdentifyCompositorTextureHost(textureFactoryIdentifier);
|
|
gfx::VRManagerChild::IdentifyTextureHost(textureFactoryIdentifier);
|
|
}
|
|
}
|
|
|
|
WindowUsesOMTC();
|
|
|
|
mLayerManager = lm.forget();
|
|
|
|
// Only track compositors for top-level windows, since other window types
|
|
// may use the basic compositor. Except on the OS X - see bug 1306383
|
|
#if defined(XP_MACOSX)
|
|
bool getCompositorFromThisWindow = true;
|
|
#else
|
|
bool getCompositorFromThisWindow = (mWindowType == eWindowType_toplevel);
|
|
#endif
|
|
|
|
if (getCompositorFromThisWindow) {
|
|
gfxPlatform::GetPlatform()->NotifyCompositorCreated(mLayerManager->GetCompositorBackendType());
|
|
}
|
|
}
|
|
|
|
void nsBaseWidget::NotifyRemoteCompositorSessionLost(CompositorSession* aSession)
|
|
{
|
|
MOZ_ASSERT(aSession == mCompositorSession);
|
|
DestroyLayerManager();
|
|
}
|
|
|
|
bool nsBaseWidget::ShouldUseOffMainThreadCompositing()
|
|
{
|
|
return gfxPlatform::UsesOffMainThreadCompositing();
|
|
}
|
|
|
|
LayerManager* nsBaseWidget::GetLayerManager(PLayerTransactionChild* aShadowManager,
|
|
LayersBackend aBackendHint,
|
|
LayerManagerPersistence aPersistence)
|
|
{
|
|
if (!mLayerManager) {
|
|
if (!mShutdownObserver) {
|
|
// We are shutting down, do not try to re-create a LayerManager
|
|
return nullptr;
|
|
}
|
|
// Try to use an async compositor first, if possible
|
|
if (ShouldUseOffMainThreadCompositing()) {
|
|
// e10s uses the parameter to pass in the shadow manager from the TabChild
|
|
// so we don't expect to see it there since this doesn't support e10s.
|
|
NS_ASSERTION(aShadowManager == nullptr, "Async Compositor not supported with e10s");
|
|
CreateCompositor();
|
|
}
|
|
|
|
if (!mLayerManager) {
|
|
mLayerManager = CreateBasicLayerManager();
|
|
}
|
|
}
|
|
return mLayerManager;
|
|
}
|
|
|
|
LayerManager* nsBaseWidget::CreateBasicLayerManager()
|
|
{
|
|
return new BasicLayerManager(this);
|
|
}
|
|
|
|
CompositorBridgeChild* nsBaseWidget::GetRemoteRenderer()
|
|
{
|
|
return mCompositorBridgeChild;
|
|
}
|
|
|
|
already_AddRefed<gfx::DrawTarget>
|
|
nsBaseWidget::StartRemoteDrawing()
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t
|
|
nsBaseWidget::GetGLFrameBufferFormat()
|
|
{
|
|
return LOCAL_GL_RGBA;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Destroy the window
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void nsBaseWidget::OnDestroy()
|
|
{
|
|
if (mTextEventDispatcher) {
|
|
mTextEventDispatcher->OnDestroyWidget();
|
|
// Don't release it until this widget actually released because after this
|
|
// is called, TextEventDispatcher() may create it again.
|
|
}
|
|
|
|
// If this widget is being destroyed, let the APZ code know to drop references
|
|
// to this widget. Callers of this function all should be holding a deathgrip
|
|
// on this widget already.
|
|
ReleaseContentController();
|
|
}
|
|
|
|
NS_IMETHODIMP nsBaseWidget::MoveClient(double aX, double aY)
|
|
{
|
|
LayoutDeviceIntPoint clientOffset(GetClientOffset());
|
|
|
|
// GetClientOffset returns device pixels; scale back to desktop pixels
|
|
// if that's what this widget uses for the Move/Resize APIs
|
|
if (BoundsUseDesktopPixels()) {
|
|
DesktopPoint desktopOffset = clientOffset / GetDesktopToDeviceScale();
|
|
return Move(aX - desktopOffset.x, aY - desktopOffset.y);
|
|
} else {
|
|
return Move(aX - clientOffset.x, aY - clientOffset.y);
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP nsBaseWidget::ResizeClient(double aWidth,
|
|
double aHeight,
|
|
bool aRepaint)
|
|
{
|
|
NS_ASSERTION((aWidth >=0) , "Negative width passed to ResizeClient");
|
|
NS_ASSERTION((aHeight >=0), "Negative height passed to ResizeClient");
|
|
|
|
LayoutDeviceIntRect clientBounds = GetClientBounds();
|
|
|
|
// GetClientBounds and mBounds are device pixels; scale back to desktop pixels
|
|
// if that's what this widget uses for the Move/Resize APIs
|
|
if (BoundsUseDesktopPixels()) {
|
|
DesktopSize desktopDelta =
|
|
(LayoutDeviceIntSize(mBounds.width, mBounds.height) -
|
|
clientBounds.Size()) / GetDesktopToDeviceScale();
|
|
return Resize(aWidth + desktopDelta.width, aHeight + desktopDelta.height,
|
|
aRepaint);
|
|
} else {
|
|
return Resize(mBounds.width + (aWidth - clientBounds.width),
|
|
mBounds.height + (aHeight - clientBounds.height), aRepaint);
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP nsBaseWidget::ResizeClient(double aX,
|
|
double aY,
|
|
double aWidth,
|
|
double aHeight,
|
|
bool aRepaint)
|
|
{
|
|
NS_ASSERTION((aWidth >=0) , "Negative width passed to ResizeClient");
|
|
NS_ASSERTION((aHeight >=0), "Negative height passed to ResizeClient");
|
|
|
|
LayoutDeviceIntRect clientBounds = GetClientBounds();
|
|
LayoutDeviceIntPoint clientOffset = GetClientOffset();
|
|
|
|
if (BoundsUseDesktopPixels()) {
|
|
DesktopToLayoutDeviceScale scale = GetDesktopToDeviceScale();
|
|
DesktopPoint desktopOffset = clientOffset / scale;
|
|
DesktopSize desktopDelta =
|
|
(LayoutDeviceIntSize(mBounds.width, mBounds.height) -
|
|
clientBounds.Size()) / scale;
|
|
return Resize(aX - desktopOffset.x, aY - desktopOffset.y,
|
|
aWidth + desktopDelta.width, aHeight + desktopDelta.height,
|
|
aRepaint);
|
|
} else {
|
|
return Resize(aX - clientOffset.x, aY - clientOffset.y,
|
|
aWidth + mBounds.width - clientBounds.width,
|
|
aHeight + mBounds.height - clientBounds.height,
|
|
aRepaint);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// Bounds
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
/**
|
|
* If the implementation of nsWindow supports borders this method MUST be overridden
|
|
*
|
|
**/
|
|
LayoutDeviceIntRect
|
|
nsBaseWidget::GetClientBounds()
|
|
{
|
|
return GetBounds();
|
|
}
|
|
|
|
/**
|
|
* If the implementation of nsWindow supports borders this method MUST be overridden
|
|
*
|
|
**/
|
|
LayoutDeviceIntRect
|
|
nsBaseWidget::GetBounds()
|
|
{
|
|
return mBounds;
|
|
}
|
|
|
|
/**
|
|
* If the implementation of nsWindow uses a local coordinate system within the window,
|
|
* this method must be overridden
|
|
*
|
|
**/
|
|
LayoutDeviceIntRect
|
|
nsBaseWidget::GetScreenBounds()
|
|
{
|
|
return GetBounds();
|
|
}
|
|
|
|
nsresult
|
|
nsBaseWidget::GetRestoredBounds(LayoutDeviceIntRect& aRect)
|
|
{
|
|
if (SizeMode() != nsSizeMode_Normal) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
aRect = GetScreenBounds();
|
|
return NS_OK;
|
|
}
|
|
|
|
LayoutDeviceIntPoint
|
|
nsBaseWidget::GetClientOffset()
|
|
{
|
|
return LayoutDeviceIntPoint(0, 0);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseWidget::SetNonClientMargins(LayoutDeviceIntMargin &margins)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
uint32_t nsBaseWidget::GetMaxTouchPoints() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseWidget::GetAttention(int32_t aCycleCount) {
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsBaseWidget::HasPendingInputEvent()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseWidget::SetIcon(const nsAString&)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsBaseWidget::ShowsResizeIndicator(LayoutDeviceIntRect* aResizerRect)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Modifies aFile to point at an icon file with the given name and suffix. The
|
|
* suffix may correspond to a file extension with leading '.' if appropriate.
|
|
* Returns true if the icon file exists and can be read.
|
|
*/
|
|
static bool
|
|
ResolveIconNameHelper(nsIFile *aFile,
|
|
const nsAString &aIconName,
|
|
const nsAString &aIconSuffix)
|
|
{
|
|
aFile->Append(NS_LITERAL_STRING("icons"));
|
|
aFile->Append(NS_LITERAL_STRING("default"));
|
|
aFile->Append(aIconName + aIconSuffix);
|
|
|
|
bool readable;
|
|
return NS_SUCCEEDED(aFile->IsReadable(&readable)) && readable;
|
|
}
|
|
|
|
/**
|
|
* Resolve the given icon name into a local file object. This method is
|
|
* intended to be called by subclasses of nsBaseWidget. aIconSuffix is a
|
|
* platform specific icon file suffix (e.g., ".ico" under Win32).
|
|
*
|
|
* If no file is found matching the given parameters, then null is returned.
|
|
*/
|
|
void
|
|
nsBaseWidget::ResolveIconName(const nsAString &aIconName,
|
|
const nsAString &aIconSuffix,
|
|
nsIFile **aResult)
|
|
{
|
|
*aResult = nullptr;
|
|
|
|
nsCOMPtr<nsIProperties> dirSvc = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
|
|
if (!dirSvc)
|
|
return;
|
|
|
|
// first check auxilary chrome directories
|
|
|
|
nsCOMPtr<nsISimpleEnumerator> dirs;
|
|
dirSvc->Get(NS_APP_CHROME_DIR_LIST, NS_GET_IID(nsISimpleEnumerator),
|
|
getter_AddRefs(dirs));
|
|
if (dirs) {
|
|
bool hasMore;
|
|
while (NS_SUCCEEDED(dirs->HasMoreElements(&hasMore)) && hasMore) {
|
|
nsCOMPtr<nsISupports> element;
|
|
dirs->GetNext(getter_AddRefs(element));
|
|
if (!element)
|
|
continue;
|
|
nsCOMPtr<nsIFile> file = do_QueryInterface(element);
|
|
if (!file)
|
|
continue;
|
|
if (ResolveIconNameHelper(file, aIconName, aIconSuffix)) {
|
|
NS_ADDREF(*aResult = file);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// then check the main app chrome directory
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
dirSvc->Get(NS_APP_CHROME_DIR, NS_GET_IID(nsIFile),
|
|
getter_AddRefs(file));
|
|
if (file && ResolveIconNameHelper(file, aIconName, aIconSuffix))
|
|
NS_ADDREF(*aResult = file);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseWidget::BeginResizeDrag(WidgetGUIEvent* aEvent,
|
|
int32_t aHorizontal,
|
|
int32_t aVertical)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseWidget::BeginMoveDrag(WidgetMouseEvent* aEvent)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
void nsBaseWidget::SetSizeConstraints(const SizeConstraints& aConstraints)
|
|
{
|
|
mSizeConstraints = aConstraints;
|
|
// We can't ensure that the size is honored at this point because we're
|
|
// probably in the middle of a reflow.
|
|
}
|
|
|
|
const widget::SizeConstraints nsBaseWidget::GetSizeConstraints()
|
|
{
|
|
return mSizeConstraints;
|
|
}
|
|
|
|
// static
|
|
nsIRollupListener*
|
|
nsBaseWidget::GetActiveRollupListener()
|
|
{
|
|
// If set, then this is likely an <html:select> dropdown.
|
|
if (gRollupListener)
|
|
return gRollupListener;
|
|
|
|
return nsXULPopupManager::GetInstance();
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::NotifyWindowDestroyed()
|
|
{
|
|
if (!mWidgetListener)
|
|
return;
|
|
|
|
nsCOMPtr<nsIXULWindow> window = mWidgetListener->GetXULWindow();
|
|
nsCOMPtr<nsIBaseWindow> xulWindow(do_QueryInterface(window));
|
|
if (xulWindow) {
|
|
xulWindow->Destroy();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::NotifySizeMoveDone()
|
|
{
|
|
if (!mWidgetListener || mWidgetListener->GetXULWindow())
|
|
return;
|
|
|
|
nsIPresShell* presShell = mWidgetListener->GetPresShell();
|
|
if (presShell) {
|
|
presShell->WindowSizeMoveDone();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::NotifyWindowMoved(int32_t aX, int32_t aY)
|
|
{
|
|
if (mWidgetListener) {
|
|
mWidgetListener->WindowMoved(this, aX, aY);
|
|
}
|
|
|
|
if (mIMEHasFocus && GetIMEUpdatePreference().WantPositionChanged()) {
|
|
NotifyIME(IMENotification(IMEMessage::NOTIFY_IME_OF_POSITION_CHANGE));
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::NotifySysColorChanged()
|
|
{
|
|
if (!mWidgetListener || mWidgetListener->GetXULWindow())
|
|
return;
|
|
|
|
nsIPresShell* presShell = mWidgetListener->GetPresShell();
|
|
if (presShell) {
|
|
presShell->SysColorChanged();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::NotifyThemeChanged()
|
|
{
|
|
if (!mWidgetListener || mWidgetListener->GetXULWindow())
|
|
return;
|
|
|
|
nsIPresShell* presShell = mWidgetListener->GetPresShell();
|
|
if (presShell) {
|
|
presShell->ThemeChanged();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::NotifyUIStateChanged(UIStateChangeType aShowAccelerators,
|
|
UIStateChangeType aShowFocusRings)
|
|
{
|
|
if (nsIDocument* doc = GetDocument()) {
|
|
nsPIDOMWindowOuter* win = doc->GetWindow();
|
|
if (win) {
|
|
win->SetKeyboardIndicators(aShowAccelerators, aShowFocusRings);
|
|
}
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsBaseWidget::NotifyIME(const IMENotification& aIMENotification)
|
|
{
|
|
switch (aIMENotification.mMessage) {
|
|
case REQUEST_TO_COMMIT_COMPOSITION:
|
|
case REQUEST_TO_CANCEL_COMPOSITION:
|
|
// Currently, if native IME handler doesn't use TextEventDispatcher,
|
|
// the request may be notified to mTextEventDispatcher or native IME
|
|
// directly. Therefore, if mTextEventDispatcher has a composition,
|
|
// the request should be handled by the mTextEventDispatcher.
|
|
if (mTextEventDispatcher && mTextEventDispatcher->IsComposing()) {
|
|
return mTextEventDispatcher->NotifyIME(aIMENotification);
|
|
}
|
|
// Otherwise, it should be handled by native IME.
|
|
return NotifyIMEInternal(aIMENotification);
|
|
default: {
|
|
if (aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS) {
|
|
mIMEHasFocus = true;
|
|
}
|
|
EnsureTextEventDispatcher();
|
|
// If the platform specific widget uses TextEventDispatcher for handling
|
|
// native IME and keyboard events, IME event handler should be notified
|
|
// of the notification via TextEventDispatcher. Otherwise, on the other
|
|
// platforms which have not used TextEventDispatcher yet, IME event
|
|
// handler should be notified by the old path (NotifyIMEInternal).
|
|
nsresult rv = mTextEventDispatcher->NotifyIME(aIMENotification);
|
|
nsresult rv2 = NotifyIMEInternal(aIMENotification);
|
|
if (aIMENotification.mMessage == NOTIFY_IME_OF_BLUR) {
|
|
mIMEHasFocus = false;
|
|
}
|
|
return rv2 == NS_ERROR_NOT_IMPLEMENTED ? rv : rv2;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::EnsureTextEventDispatcher()
|
|
{
|
|
if (mTextEventDispatcher) {
|
|
return;
|
|
}
|
|
mTextEventDispatcher = new TextEventDispatcher(this);
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsIWidget::TextEventDispatcher*)
|
|
nsBaseWidget::GetTextEventDispatcher()
|
|
{
|
|
EnsureTextEventDispatcher();
|
|
return mTextEventDispatcher;
|
|
}
|
|
|
|
void*
|
|
nsBaseWidget::GetPseudoIMEContext()
|
|
{
|
|
TextEventDispatcher* dispatcher = GetTextEventDispatcher();
|
|
if (!dispatcher) {
|
|
return nullptr;
|
|
}
|
|
return dispatcher->GetPseudoIMEContext();
|
|
}
|
|
|
|
NS_IMETHODIMP_(TextEventDispatcherListener*)
|
|
nsBaseWidget::GetNativeTextEventDispatcherListener()
|
|
{
|
|
// TODO: If all platforms supported use of TextEventDispatcher for handling
|
|
// native IME and keyboard events, this method should be removed since
|
|
// in such case, this is overridden by all the subclasses.
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::ZoomToRect(const uint32_t& aPresShellId,
|
|
const FrameMetrics::ViewID& aViewId,
|
|
const CSSRect& aRect,
|
|
const uint32_t& aFlags)
|
|
{
|
|
if (!mCompositorSession || !mAPZC) {
|
|
return;
|
|
}
|
|
uint64_t layerId = mCompositorSession->RootLayerTreeId();
|
|
mAPZC->ZoomToRect(ScrollableLayerGuid(layerId, aPresShellId, aViewId), aRect, aFlags);
|
|
}
|
|
|
|
#ifdef ACCESSIBILITY
|
|
|
|
#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
|
|
// defined in nsAppRunner.cpp
|
|
extern const char* kAccessibilityLastRunDatePref;
|
|
|
|
static inline uint32_t
|
|
PRTimeToSeconds(PRTime t_usec)
|
|
{
|
|
PRTime usec_per_sec = PR_USEC_PER_SEC;
|
|
return uint32_t(t_usec /= usec_per_sec);
|
|
}
|
|
#endif
|
|
|
|
a11y::Accessible*
|
|
nsBaseWidget::GetRootAccessible()
|
|
{
|
|
NS_ENSURE_TRUE(mWidgetListener, nullptr);
|
|
|
|
nsIPresShell* presShell = mWidgetListener->GetPresShell();
|
|
NS_ENSURE_TRUE(presShell, nullptr);
|
|
|
|
// If container is null then the presshell is not active. This often happens
|
|
// when a preshell is being held onto for fastback.
|
|
nsPresContext* presContext = presShell->GetPresContext();
|
|
NS_ENSURE_TRUE(presContext->GetContainerWeak(), nullptr);
|
|
|
|
// Accessible creation might be not safe so use IsSafeToRunScript to
|
|
// make sure it's not created at unsafe times.
|
|
nsAccessibilityService* accService = GetOrCreateAccService();
|
|
if (accService) {
|
|
#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
|
|
if (!mAccessibilityInUseFlag) {
|
|
mAccessibilityInUseFlag = true;
|
|
uint32_t now = PRTimeToSeconds(PR_Now());
|
|
Preferences::SetInt(kAccessibilityLastRunDatePref, now);
|
|
}
|
|
#endif
|
|
return accService->GetRootDocumentAccessible(presShell, nsContentUtils::IsSafeToRunScript());
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
#endif // ACCESSIBILITY
|
|
|
|
void
|
|
nsBaseWidget::StartAsyncScrollbarDrag(const AsyncDragMetrics& aDragMetrics)
|
|
{
|
|
if (!AsyncPanZoomEnabled()) {
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(XRE_IsParentProcess() && mCompositorSession);
|
|
|
|
int layersId = mCompositorSession->RootLayerTreeId();;
|
|
ScrollableLayerGuid guid(layersId, aDragMetrics.mPresShellId, aDragMetrics.mViewId);
|
|
|
|
APZThreadUtils::RunOnControllerThread(NewRunnableMethod
|
|
<ScrollableLayerGuid, AsyncDragMetrics>(mAPZC,
|
|
&IAPZCTreeManager::StartScrollbarDrag,
|
|
guid, aDragMetrics));
|
|
}
|
|
|
|
already_AddRefed<nsIScreen>
|
|
nsBaseWidget::GetWidgetScreen()
|
|
{
|
|
nsCOMPtr<nsIScreenManager> screenManager;
|
|
screenManager = do_GetService("@mozilla.org/gfx/screenmanager;1");
|
|
if (!screenManager) {
|
|
return nullptr;
|
|
}
|
|
|
|
LayoutDeviceIntRect bounds = GetScreenBounds();
|
|
DesktopIntRect deskBounds = RoundedToInt(bounds / GetDesktopToDeviceScale());
|
|
nsCOMPtr<nsIScreen> screen;
|
|
screenManager->ScreenForRect(deskBounds.x, deskBounds.y,
|
|
deskBounds.width, deskBounds.height,
|
|
getter_AddRefs(screen));
|
|
return screen.forget();
|
|
}
|
|
|
|
nsresult
|
|
nsIWidget::SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint, bool aLongTap,
|
|
nsIObserver* aObserver)
|
|
{
|
|
AutoObserverNotifier notifier(aObserver, "touchtap");
|
|
|
|
if (sPointerIdCounter > TOUCH_INJECT_MAX_POINTS) {
|
|
sPointerIdCounter = 0;
|
|
}
|
|
int pointerId = sPointerIdCounter;
|
|
sPointerIdCounter++;
|
|
nsresult rv = SynthesizeNativeTouchPoint(pointerId, TOUCH_CONTACT,
|
|
aPoint, 1.0, 90, nullptr);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
if (!aLongTap) {
|
|
return SynthesizeNativeTouchPoint(pointerId, TOUCH_REMOVE,
|
|
aPoint, 0, 0, nullptr);
|
|
}
|
|
|
|
// initiate a long tap
|
|
int elapse = Preferences::GetInt("ui.click_hold_context_menus.delay",
|
|
TOUCH_INJECT_LONG_TAP_DEFAULT_MSEC);
|
|
if (!mLongTapTimer) {
|
|
mLongTapTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
|
|
if (NS_FAILED(rv)) {
|
|
SynthesizeNativeTouchPoint(pointerId, TOUCH_CANCEL,
|
|
aPoint, 0, 0, nullptr);
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
// Windows requires recuring events, so we set this to a smaller window
|
|
// than the pref value.
|
|
int timeout = elapse;
|
|
if (timeout > TOUCH_INJECT_PUMP_TIMER_MSEC) {
|
|
timeout = TOUCH_INJECT_PUMP_TIMER_MSEC;
|
|
}
|
|
mLongTapTimer->InitWithFuncCallback(OnLongTapTimerCallback, this,
|
|
timeout,
|
|
nsITimer::TYPE_REPEATING_SLACK);
|
|
}
|
|
|
|
// If we already have a long tap pending, cancel it. We only allow one long
|
|
// tap to be active at a time.
|
|
if (mLongTapTouchPoint) {
|
|
SynthesizeNativeTouchPoint(mLongTapTouchPoint->mPointerId, TOUCH_CANCEL,
|
|
mLongTapTouchPoint->mPosition, 0, 0, nullptr);
|
|
}
|
|
|
|
mLongTapTouchPoint =
|
|
MakeUnique<LongTapInfo>(pointerId, aPoint,
|
|
TimeDuration::FromMilliseconds(elapse),
|
|
aObserver);
|
|
notifier.SkipNotification(); // we'll do it in the long-tap callback
|
|
return NS_OK;
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsIWidget::OnLongTapTimerCallback(nsITimer* aTimer, void* aClosure)
|
|
{
|
|
nsIWidget *self = static_cast<nsIWidget *>(aClosure);
|
|
|
|
if ((self->mLongTapTouchPoint->mStamp + self->mLongTapTouchPoint->mDuration) >
|
|
TimeStamp::Now()) {
|
|
#ifdef XP_WIN
|
|
// Windows needs us to keep pumping feedback to the digitizer, so update
|
|
// the pointer id with the same position.
|
|
self->SynthesizeNativeTouchPoint(self->mLongTapTouchPoint->mPointerId,
|
|
TOUCH_CONTACT,
|
|
self->mLongTapTouchPoint->mPosition,
|
|
1.0, 90, nullptr);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
AutoObserverNotifier notifier(self->mLongTapTouchPoint->mObserver, "touchtap");
|
|
|
|
// finished, remove the touch point
|
|
self->mLongTapTimer->Cancel();
|
|
self->mLongTapTimer = nullptr;
|
|
self->SynthesizeNativeTouchPoint(self->mLongTapTouchPoint->mPointerId,
|
|
TOUCH_REMOVE,
|
|
self->mLongTapTouchPoint->mPosition,
|
|
0, 0, nullptr);
|
|
self->mLongTapTouchPoint = nullptr;
|
|
}
|
|
|
|
nsresult
|
|
nsIWidget::ClearNativeTouchSequence(nsIObserver* aObserver)
|
|
{
|
|
AutoObserverNotifier notifier(aObserver, "cleartouch");
|
|
|
|
if (!mLongTapTimer) {
|
|
return NS_OK;
|
|
}
|
|
mLongTapTimer->Cancel();
|
|
mLongTapTimer = nullptr;
|
|
SynthesizeNativeTouchPoint(mLongTapTouchPoint->mPointerId, TOUCH_CANCEL,
|
|
mLongTapTouchPoint->mPosition, 0, 0, nullptr);
|
|
mLongTapTouchPoint = nullptr;
|
|
return NS_OK;
|
|
}
|
|
|
|
MultiTouchInput
|
|
nsBaseWidget::UpdateSynthesizedTouchState(MultiTouchInput* aState,
|
|
uint32_t aTime,
|
|
mozilla::TimeStamp aTimeStamp,
|
|
uint32_t aPointerId,
|
|
TouchPointerState aPointerState,
|
|
LayoutDeviceIntPoint aPoint,
|
|
double aPointerPressure,
|
|
uint32_t aPointerOrientation)
|
|
{
|
|
ScreenIntPoint pointerScreenPoint = ViewAs<ScreenPixel>(aPoint,
|
|
PixelCastJustification::LayoutDeviceIsScreenForBounds);
|
|
|
|
// We can't dispatch *aState directly because (a) dispatching
|
|
// it might inadvertently modify it and (b) in the case of touchend or
|
|
// touchcancel events aState will hold the touches that are
|
|
// still down whereas the input dispatched needs to hold the removed
|
|
// touch(es). We use |inputToDispatch| for this purpose.
|
|
MultiTouchInput inputToDispatch;
|
|
inputToDispatch.mInputType = MULTITOUCH_INPUT;
|
|
inputToDispatch.mTime = aTime;
|
|
inputToDispatch.mTimeStamp = aTimeStamp;
|
|
|
|
int32_t index = aState->IndexOfTouch((int32_t)aPointerId);
|
|
if (aPointerState == TOUCH_CONTACT) {
|
|
if (index >= 0) {
|
|
// found an existing touch point, update it
|
|
SingleTouchData& point = aState->mTouches[index];
|
|
point.mScreenPoint = pointerScreenPoint;
|
|
point.mRotationAngle = (float)aPointerOrientation;
|
|
point.mForce = (float)aPointerPressure;
|
|
inputToDispatch.mType = MultiTouchInput::MULTITOUCH_MOVE;
|
|
} else {
|
|
// new touch point, add it
|
|
aState->mTouches.AppendElement(SingleTouchData(
|
|
(int32_t)aPointerId,
|
|
pointerScreenPoint,
|
|
ScreenSize(0, 0),
|
|
(float)aPointerOrientation,
|
|
(float)aPointerPressure));
|
|
inputToDispatch.mType = MultiTouchInput::MULTITOUCH_START;
|
|
}
|
|
inputToDispatch.mTouches = aState->mTouches;
|
|
} else {
|
|
MOZ_ASSERT(aPointerState == TOUCH_REMOVE || aPointerState == TOUCH_CANCEL);
|
|
// a touch point is being lifted, so remove it from the stored list
|
|
if (index >= 0) {
|
|
aState->mTouches.RemoveElementAt(index);
|
|
}
|
|
inputToDispatch.mType = (aPointerState == TOUCH_REMOVE
|
|
? MultiTouchInput::MULTITOUCH_END
|
|
: MultiTouchInput::MULTITOUCH_CANCEL);
|
|
inputToDispatch.mTouches.AppendElement(SingleTouchData(
|
|
(int32_t)aPointerId,
|
|
pointerScreenPoint,
|
|
ScreenSize(0, 0),
|
|
(float)aPointerOrientation,
|
|
(float)aPointerPressure));
|
|
}
|
|
|
|
return inputToDispatch;
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::RegisterPluginWindowForRemoteUpdates()
|
|
{
|
|
#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
|
|
NS_NOTREACHED("nsBaseWidget::RegisterPluginWindowForRemoteUpdates not implemented!");
|
|
return;
|
|
#else
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
void* id = GetNativeData(NS_NATIVE_PLUGIN_ID);
|
|
if (!id) {
|
|
NS_WARNING("This is not a valid native widget!");
|
|
return;
|
|
}
|
|
MOZ_ASSERT(sPluginWidgetList);
|
|
sPluginWidgetList->Put(id, this);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::UnregisterPluginWindowForRemoteUpdates()
|
|
{
|
|
#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
|
|
NS_NOTREACHED("nsBaseWidget::UnregisterPluginWindowForRemoteUpdates not implemented!");
|
|
return;
|
|
#else
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
void* id = GetNativeData(NS_NATIVE_PLUGIN_ID);
|
|
if (!id) {
|
|
NS_WARNING("This is not a valid native widget!");
|
|
return;
|
|
}
|
|
MOZ_ASSERT(sPluginWidgetList);
|
|
sPluginWidgetList->Remove(id);
|
|
#endif
|
|
}
|
|
|
|
// static
|
|
nsIWidget*
|
|
nsIWidget::LookupRegisteredPluginWindow(uintptr_t aWindowID)
|
|
{
|
|
#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
|
|
NS_NOTREACHED("nsBaseWidget::LookupRegisteredPluginWindow not implemented!");
|
|
return nullptr;
|
|
#else
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(sPluginWidgetList);
|
|
return sPluginWidgetList->GetWeak((void*)aWindowID);
|
|
#endif
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsIWidget::UpdateRegisteredPluginWindowVisibility(uintptr_t aOwnerWidget,
|
|
nsTArray<uintptr_t>& aPluginIds)
|
|
{
|
|
#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
|
|
NS_NOTREACHED("nsBaseWidget::UpdateRegisteredPluginWindowVisibility not implemented!");
|
|
return;
|
|
#else
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(sPluginWidgetList);
|
|
|
|
// Our visible list is associated with a compositor which is associated with
|
|
// a specific top level window. We use the parent widget during iteration
|
|
// to skip the plugin widgets owned by other top level windows.
|
|
for (auto iter = sPluginWidgetList->Iter(); !iter.Done(); iter.Next()) {
|
|
const void* windowId = iter.Key();
|
|
nsIWidget* widget = iter.UserData();
|
|
|
|
MOZ_ASSERT(windowId);
|
|
MOZ_ASSERT(widget);
|
|
|
|
if (!widget->Destroyed()) {
|
|
if ((uintptr_t)widget->GetParent() == aOwnerWidget) {
|
|
widget->Show(aPluginIds.Contains((uintptr_t)windowId));
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if defined(XP_WIN)
|
|
// static
|
|
void
|
|
nsIWidget::CaptureRegisteredPlugins(uintptr_t aOwnerWidget)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(sPluginWidgetList);
|
|
|
|
// Our visible list is associated with a compositor which is associated with
|
|
// a specific top level window. We use the parent widget during iteration
|
|
// to skip the plugin widgets owned by other top level windows.
|
|
for (auto iter = sPluginWidgetList->Iter(); !iter.Done(); iter.Next()) {
|
|
const void* windowId = iter.Key();
|
|
nsIWidget* widget = iter.UserData();
|
|
|
|
MOZ_ASSERT(windowId);
|
|
MOZ_ASSERT(widget);
|
|
|
|
if (!widget->Destroyed() && widget->IsVisible()) {
|
|
if ((uintptr_t)widget->GetParent() == aOwnerWidget) {
|
|
widget->UpdateScrollCapture();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uint64_t
|
|
nsBaseWidget::CreateScrollCaptureContainer()
|
|
{
|
|
mScrollCaptureContainer =
|
|
LayerManager::CreateImageContainer(ImageContainer::ASYNCHRONOUS);
|
|
if (!mScrollCaptureContainer) {
|
|
NS_WARNING("Failed to create ImageContainer for widget image capture.");
|
|
return ImageContainer::sInvalidAsyncContainerId;
|
|
}
|
|
|
|
return mScrollCaptureContainer->GetAsyncContainerID();
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::UpdateScrollCapture()
|
|
{
|
|
// Don't capture if no container or no size.
|
|
if (!mScrollCaptureContainer || mBounds.width <= 0 || mBounds.height <= 0) {
|
|
return;
|
|
}
|
|
|
|
// If the derived class cannot take a snapshot, for example due to clipping,
|
|
// then it is responsible for creating a fallback. If null is returned, this
|
|
// means that we want to keep the existing snapshot.
|
|
RefPtr<gfx::SourceSurface> snapshot = CreateScrollSnapshot();
|
|
if (!snapshot) {
|
|
return;
|
|
}
|
|
|
|
ImageContainer::NonOwningImage holder(new SourceSurfaceImage(snapshot));
|
|
|
|
AutoTArray<ImageContainer::NonOwningImage, 1> imageList;
|
|
imageList.AppendElement(holder);
|
|
|
|
mScrollCaptureContainer->SetCurrentImages(imageList);
|
|
}
|
|
|
|
void
|
|
nsBaseWidget::DefaultFillScrollCapture(DrawTarget* aSnapshotDrawTarget)
|
|
{
|
|
gfx::IntSize dtSize = aSnapshotDrawTarget->GetSize();
|
|
aSnapshotDrawTarget->FillRect(
|
|
gfx::Rect(0, 0, dtSize.width, dtSize.height),
|
|
gfx::ColorPattern(gfx::Color::FromABGR(kScrollCaptureFillColor)),
|
|
gfx::DrawOptions(1.f, gfx::CompositionOp::OP_SOURCE));
|
|
aSnapshotDrawTarget->Flush();
|
|
}
|
|
#endif
|
|
|
|
NS_IMETHODIMP_(nsIWidget::NativeIMEContext)
|
|
nsIWidget::GetNativeIMEContext()
|
|
{
|
|
return NativeIMEContext(this);
|
|
}
|
|
|
|
nsresult
|
|
nsIWidget::OnWindowedPluginKeyEvent(const NativeEventData& aKeyEventData,
|
|
nsIKeyEventInPluginCallback* aCallback)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
const char*
|
|
ToChar(IMEMessage aIMEMessage)
|
|
{
|
|
switch (aIMEMessage) {
|
|
case NOTIFY_IME_OF_NOTHING:
|
|
return "NOTIFY_IME_OF_NOTHING";
|
|
case NOTIFY_IME_OF_FOCUS:
|
|
return "NOTIFY_IME_OF_FOCUS";
|
|
case NOTIFY_IME_OF_BLUR:
|
|
return "NOTIFY_IME_OF_BLUR";
|
|
case NOTIFY_IME_OF_SELECTION_CHANGE:
|
|
return "NOTIFY_IME_OF_SELECTION_CHANGE";
|
|
case NOTIFY_IME_OF_TEXT_CHANGE:
|
|
return "NOTIFY_IME_OF_TEXT_CHANGE";
|
|
case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED:
|
|
return "NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED";
|
|
case NOTIFY_IME_OF_POSITION_CHANGE:
|
|
return "NOTIFY_IME_OF_POSITION_CHANGE";
|
|
case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
|
|
return "NOTIFY_IME_OF_MOUSE_BUTTON_EVENT";
|
|
case REQUEST_TO_COMMIT_COMPOSITION:
|
|
return "REQUEST_TO_COMMIT_COMPOSITION";
|
|
case REQUEST_TO_CANCEL_COMPOSITION:
|
|
return "REQUEST_TO_CANCEL_COMPOSITION";
|
|
default:
|
|
return "Unexpected value";
|
|
}
|
|
}
|
|
|
|
void
|
|
NativeIMEContext::Init(nsIWidget* aWidget)
|
|
{
|
|
if (!aWidget) {
|
|
mRawNativeIMEContext = reinterpret_cast<uintptr_t>(nullptr);
|
|
mOriginProcessID = static_cast<uint64_t>(-1);
|
|
return;
|
|
}
|
|
if (!XRE_IsContentProcess()) {
|
|
mRawNativeIMEContext = reinterpret_cast<uintptr_t>(
|
|
aWidget->GetNativeData(NS_RAW_NATIVE_IME_CONTEXT));
|
|
mOriginProcessID = 0;
|
|
return;
|
|
}
|
|
// If this is created in a child process, aWidget is an instance of
|
|
// PuppetWidget which doesn't support NS_RAW_NATIVE_IME_CONTEXT.
|
|
// Instead of that PuppetWidget::GetNativeIMEContext() returns cached
|
|
// native IME context of the parent process.
|
|
*this = aWidget->GetNativeIMEContext();
|
|
}
|
|
|
|
void
|
|
NativeIMEContext::InitWithRawNativeIMEContext(void* aRawNativeIMEContext)
|
|
{
|
|
if (NS_WARN_IF(!aRawNativeIMEContext)) {
|
|
mRawNativeIMEContext = reinterpret_cast<uintptr_t>(nullptr);
|
|
mOriginProcessID = static_cast<uint64_t>(-1);
|
|
return;
|
|
}
|
|
mRawNativeIMEContext = reinterpret_cast<uintptr_t>(aRawNativeIMEContext);
|
|
mOriginProcessID =
|
|
XRE_IsContentProcess() ? ContentChild::GetSingleton()->GetID() : 0;
|
|
}
|
|
|
|
void
|
|
IMENotification::TextChangeDataBase::MergeWith(
|
|
const IMENotification::TextChangeDataBase& aOther)
|
|
{
|
|
MOZ_ASSERT(aOther.IsValid(),
|
|
"Merging data must store valid data");
|
|
MOZ_ASSERT(aOther.mStartOffset <= aOther.mRemovedEndOffset,
|
|
"end of removed text must be same or larger than start");
|
|
MOZ_ASSERT(aOther.mStartOffset <= aOther.mAddedEndOffset,
|
|
"end of added text must be same or larger than start");
|
|
|
|
if (!IsValid()) {
|
|
*this = aOther;
|
|
return;
|
|
}
|
|
|
|
// |mStartOffset| and |mRemovedEndOffset| represent all replaced or removed
|
|
// text ranges. I.e., mStartOffset should be the smallest offset of all
|
|
// modified text ranges in old text. |mRemovedEndOffset| should be the
|
|
// largest end offset in old text of all modified text ranges.
|
|
// |mAddedEndOffset| represents the end offset of all inserted text ranges.
|
|
// I.e., only this is an offset in new text.
|
|
// In other words, between mStartOffset and |mRemovedEndOffset| of the
|
|
// premodified text was already removed. And some text whose length is
|
|
// |mAddedEndOffset - mStartOffset| is inserted to |mStartOffset|. I.e.,
|
|
// this allows IME to mark dirty the modified text range with |mStartOffset|
|
|
// and |mRemovedEndOffset| if IME stores all text of the focused editor and
|
|
// to compute new text length with |mAddedEndOffset| and |mRemovedEndOffset|.
|
|
// Additionally, IME can retrieve only the text between |mStartOffset| and
|
|
// |mAddedEndOffset| for updating stored text.
|
|
|
|
// For comparing new and old |mStartOffset|/|mRemovedEndOffset| values, they
|
|
// should be adjusted to be in same text. The |newData.mStartOffset| and
|
|
// |newData.mRemovedEndOffset| should be computed as in old text because
|
|
// |mStartOffset| and |mRemovedEndOffset| represent the modified text range
|
|
// in the old text but even if some text before the values of the newData
|
|
// has already been modified, the values don't include the changes.
|
|
|
|
// For comparing new and old |mAddedEndOffset| values, they should be
|
|
// adjusted to be in same text. The |oldData.mAddedEndOffset| should be
|
|
// computed as in the new text because |mAddedEndOffset| indicates the end
|
|
// offset of inserted text in the new text but |oldData.mAddedEndOffset|
|
|
// doesn't include any changes of the text before |newData.mAddedEndOffset|.
|
|
|
|
const TextChangeDataBase& newData = aOther;
|
|
const TextChangeDataBase oldData = *this;
|
|
|
|
// mCausedOnlyByComposition should be true only when all changes are caused
|
|
// by composition.
|
|
mCausedOnlyByComposition =
|
|
newData.mCausedOnlyByComposition && oldData.mCausedOnlyByComposition;
|
|
|
|
// mIncludingChangesWithoutComposition should be true if at least one of
|
|
// merged changes occurred without composition.
|
|
mIncludingChangesWithoutComposition =
|
|
newData.mIncludingChangesWithoutComposition ||
|
|
oldData.mIncludingChangesWithoutComposition;
|
|
|
|
// mIncludingChangesDuringComposition should be true when at least one of
|
|
// the merged non-composition changes occurred during the latest composition.
|
|
if (!newData.mCausedOnlyByComposition &&
|
|
!newData.mIncludingChangesDuringComposition) {
|
|
MOZ_ASSERT(newData.mIncludingChangesWithoutComposition);
|
|
MOZ_ASSERT(mIncludingChangesWithoutComposition);
|
|
// If new change is neither caused by composition nor occurred during
|
|
// composition, set mIncludingChangesDuringComposition to false because
|
|
// IME doesn't want outdated text changes as text change during current
|
|
// composition.
|
|
mIncludingChangesDuringComposition = false;
|
|
} else {
|
|
// Otherwise, set mIncludingChangesDuringComposition to true if either
|
|
// oldData or newData includes changes during composition.
|
|
mIncludingChangesDuringComposition =
|
|
newData.mIncludingChangesDuringComposition ||
|
|
oldData.mIncludingChangesDuringComposition;
|
|
}
|
|
|
|
if (newData.mStartOffset >= oldData.mAddedEndOffset) {
|
|
// Case 1:
|
|
// If new start is after old end offset of added text, it means that text
|
|
// after the modified range is modified. Like:
|
|
// added range of old change: +----------+
|
|
// removed range of new change: +----------+
|
|
// So, the old start offset is always the smaller offset.
|
|
mStartOffset = oldData.mStartOffset;
|
|
// The new end offset of removed text is moved by the old change and we
|
|
// need to cancel the move of the old change for comparing the offsets in
|
|
// same text because it doesn't make sensce to compare offsets in different
|
|
// text.
|
|
uint32_t newRemovedEndOffsetInOldText =
|
|
newData.mRemovedEndOffset - oldData.Difference();
|
|
mRemovedEndOffset =
|
|
std::max(newRemovedEndOffsetInOldText, oldData.mRemovedEndOffset);
|
|
// The new end offset of added text is always the larger offset.
|
|
mAddedEndOffset = newData.mAddedEndOffset;
|
|
return;
|
|
}
|
|
|
|
if (newData.mStartOffset >= oldData.mStartOffset) {
|
|
// If new start is in the modified range, it means that new data changes
|
|
// a part or all of the range.
|
|
mStartOffset = oldData.mStartOffset;
|
|
if (newData.mRemovedEndOffset >= oldData.mAddedEndOffset) {
|
|
// Case 2:
|
|
// If new end of removed text is greater than old end of added text, it
|
|
// means that all or a part of modified range modified again and text
|
|
// after the modified range is also modified. Like:
|
|
// added range of old change: +----------+
|
|
// removed range of new change: +----------+
|
|
// So, the new removed end offset is moved by the old change and we need
|
|
// to cancel the move of the old change for comparing the offsets in the
|
|
// same text because it doesn't make sense to compare the offsets in
|
|
// different text.
|
|
uint32_t newRemovedEndOffsetInOldText =
|
|
newData.mRemovedEndOffset - oldData.Difference();
|
|
mRemovedEndOffset =
|
|
std::max(newRemovedEndOffsetInOldText, oldData.mRemovedEndOffset);
|
|
// The old end of added text is replaced by new change. So, it should be
|
|
// same as the new start. On the other hand, the new added end offset is
|
|
// always same or larger. Therefore, the merged end offset of added
|
|
// text should be the new end offset of added text.
|
|
mAddedEndOffset = newData.mAddedEndOffset;
|
|
return;
|
|
}
|
|
|
|
// Case 3:
|
|
// If new end of removed text is less than old end of added text, it means
|
|
// that only a part of the modified range is modified again. Like:
|
|
// added range of old change: +------------+
|
|
// removed range of new change: +-----+
|
|
// So, the new end offset of removed text should be same as the old end
|
|
// offset of removed text. Therefore, the merged end offset of removed
|
|
// text should be the old text change's |mRemovedEndOffset|.
|
|
mRemovedEndOffset = oldData.mRemovedEndOffset;
|
|
// The old end of added text is moved by new change. So, we need to cancel
|
|
// the move of the new change for comparing the offsets in same text.
|
|
uint32_t oldAddedEndOffsetInNewText =
|
|
oldData.mAddedEndOffset + newData.Difference();
|
|
mAddedEndOffset =
|
|
std::max(newData.mAddedEndOffset, oldAddedEndOffsetInNewText);
|
|
return;
|
|
}
|
|
|
|
if (newData.mRemovedEndOffset >= oldData.mStartOffset) {
|
|
// If new end of removed text is greater than old start (and new start is
|
|
// less than old start), it means that a part of modified range is modified
|
|
// again and some new text before the modified range is also modified.
|
|
MOZ_ASSERT(newData.mStartOffset < oldData.mStartOffset,
|
|
"new start offset should be less than old one here");
|
|
mStartOffset = newData.mStartOffset;
|
|
if (newData.mRemovedEndOffset >= oldData.mAddedEndOffset) {
|
|
// Case 4:
|
|
// If new end of removed text is greater than old end of added text, it
|
|
// means that all modified text and text after the modified range is
|
|
// modified. Like:
|
|
// added range of old change: +----------+
|
|
// removed range of new change: +------------------+
|
|
// So, the new end of removed text is moved by the old change. Therefore,
|
|
// we need to cancel the move of the old change for comparing the offsets
|
|
// in same text because it doesn't make sense to compare the offsets in
|
|
// different text.
|
|
uint32_t newRemovedEndOffsetInOldText =
|
|
newData.mRemovedEndOffset - oldData.Difference();
|
|
mRemovedEndOffset =
|
|
std::max(newRemovedEndOffsetInOldText, oldData.mRemovedEndOffset);
|
|
// The old end of added text is replaced by new change. So, the old end
|
|
// offset of added text is same as new text change's start offset. Then,
|
|
// new change's end offset of added text is always same or larger than
|
|
// it. Therefore, merged end offset of added text is always the new end
|
|
// offset of added text.
|
|
mAddedEndOffset = newData.mAddedEndOffset;
|
|
return;
|
|
}
|
|
|
|
// Case 5:
|
|
// If new end of removed text is less than old end of added text, it
|
|
// means that only a part of the modified range is modified again. Like:
|
|
// added range of old change: +----------+
|
|
// removed range of new change: +----------+
|
|
// So, the new end of removed text should be same as old end of removed
|
|
// text for preventing end of removed text to be modified. Therefore,
|
|
// merged end offset of removed text is always the old end offset of removed
|
|
// text.
|
|
mRemovedEndOffset = oldData.mRemovedEndOffset;
|
|
// The old end of added text is moved by this change. So, we need to
|
|
// cancel the move of the new change for comparing the offsets in same text
|
|
// because it doesn't make sense to compare the offsets in different text.
|
|
uint32_t oldAddedEndOffsetInNewText =
|
|
oldData.mAddedEndOffset + newData.Difference();
|
|
mAddedEndOffset =
|
|
std::max(newData.mAddedEndOffset, oldAddedEndOffsetInNewText);
|
|
return;
|
|
}
|
|
|
|
// Case 6:
|
|
// Otherwise, i.e., both new end of added text and new start are less than
|
|
// old start, text before the modified range is modified. Like:
|
|
// added range of old change: +----------+
|
|
// removed range of new change: +----------+
|
|
MOZ_ASSERT(newData.mStartOffset < oldData.mStartOffset,
|
|
"new start offset should be less than old one here");
|
|
mStartOffset = newData.mStartOffset;
|
|
MOZ_ASSERT(newData.mRemovedEndOffset < oldData.mRemovedEndOffset,
|
|
"new removed end offset should be less than old one here");
|
|
mRemovedEndOffset = oldData.mRemovedEndOffset;
|
|
// The end of added text should be adjusted with the new difference.
|
|
uint32_t oldAddedEndOffsetInNewText =
|
|
oldData.mAddedEndOffset + newData.Difference();
|
|
mAddedEndOffset =
|
|
std::max(newData.mAddedEndOffset, oldAddedEndOffsetInNewText);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
|
|
// Let's test the code of merging multiple text change data in debug build
|
|
// and crash if one of them fails because this feature is very complex but
|
|
// cannot be tested with mochitest.
|
|
void
|
|
IMENotification::TextChangeDataBase::Test()
|
|
{
|
|
static bool gTestTextChangeEvent = true;
|
|
if (!gTestTextChangeEvent) {
|
|
return;
|
|
}
|
|
gTestTextChangeEvent = false;
|
|
|
|
/****************************************************************************
|
|
* Case 1
|
|
****************************************************************************/
|
|
|
|
// Appending text
|
|
MergeWith(TextChangeData(10, 10, 20, false, false));
|
|
MergeWith(TextChangeData(20, 20, 35, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 1-1-1: mStartOffset should be the first offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 10, // 20 - (20 - 10)
|
|
"Test 1-1-2: mRemovedEndOffset should be the first end of removed text");
|
|
MOZ_ASSERT(mAddedEndOffset == 35,
|
|
"Test 1-1-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Removing text (longer line -> shorter line)
|
|
MergeWith(TextChangeData(10, 20, 10, false, false));
|
|
MergeWith(TextChangeData(10, 30, 10, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 1-2-1: mStartOffset should be the first offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 40, // 30 + (10 - 20)
|
|
"Test 1-2-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"with already removed length");
|
|
MOZ_ASSERT(mAddedEndOffset == 10,
|
|
"Test 1-2-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Removing text (shorter line -> longer line)
|
|
MergeWith(TextChangeData(10, 20, 10, false, false));
|
|
MergeWith(TextChangeData(10, 15, 10, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 1-3-1: mStartOffset should be the first offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 25, // 15 + (10 - 20)
|
|
"Test 1-3-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"with already removed length");
|
|
MOZ_ASSERT(mAddedEndOffset == 10,
|
|
"Test 1-3-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Appending text at different point (not sure if actually occurs)
|
|
MergeWith(TextChangeData(10, 10, 20, false, false));
|
|
MergeWith(TextChangeData(55, 55, 60, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 1-4-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 45, // 55 - (10 - 20)
|
|
"Test 1-4-2: mRemovedEndOffset should be the the largest end of removed "
|
|
"text without already added length");
|
|
MOZ_ASSERT(mAddedEndOffset == 60,
|
|
"Test 1-4-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Removing text at different point (not sure if actually occurs)
|
|
MergeWith(TextChangeData(10, 20, 10, false, false));
|
|
MergeWith(TextChangeData(55, 68, 55, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 1-5-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 78, // 68 - (10 - 20)
|
|
"Test 1-5-2: mRemovedEndOffset should be the the largest end of removed "
|
|
"text with already removed length");
|
|
MOZ_ASSERT(mAddedEndOffset == 55,
|
|
"Test 1-5-3: mAddedEndOffset should be the largest end of added text");
|
|
Clear();
|
|
|
|
// Replacing text and append text (becomes longer)
|
|
MergeWith(TextChangeData(30, 35, 32, false, false));
|
|
MergeWith(TextChangeData(32, 32, 40, false, false));
|
|
MOZ_ASSERT(mStartOffset == 30,
|
|
"Test 1-6-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 35, // 32 - (32 - 35)
|
|
"Test 1-6-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 40,
|
|
"Test 1-6-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text and append text (becomes shorter)
|
|
MergeWith(TextChangeData(30, 35, 32, false, false));
|
|
MergeWith(TextChangeData(32, 32, 33, false, false));
|
|
MOZ_ASSERT(mStartOffset == 30,
|
|
"Test 1-7-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 35, // 32 - (32 - 35)
|
|
"Test 1-7-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 33,
|
|
"Test 1-7-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Removing text and replacing text after first range (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(30, 35, 30, false, false));
|
|
MergeWith(TextChangeData(32, 34, 48, false, false));
|
|
MOZ_ASSERT(mStartOffset == 30,
|
|
"Test 1-8-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 39, // 34 - (30 - 35)
|
|
"Test 1-8-2: mRemovedEndOffset should be the the first end of removed text "
|
|
"without already removed text");
|
|
MOZ_ASSERT(mAddedEndOffset == 48,
|
|
"Test 1-8-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Removing text and replacing text after first range (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(30, 35, 30, false, false));
|
|
MergeWith(TextChangeData(32, 38, 36, false, false));
|
|
MOZ_ASSERT(mStartOffset == 30,
|
|
"Test 1-9-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 43, // 38 - (30 - 35)
|
|
"Test 1-9-2: mRemovedEndOffset should be the the first end of removed text "
|
|
"without already removed text");
|
|
MOZ_ASSERT(mAddedEndOffset == 36,
|
|
"Test 1-9-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
/****************************************************************************
|
|
* Case 2
|
|
****************************************************************************/
|
|
|
|
// Replacing text in around end of added text (becomes shorter) (not sure
|
|
// if actually occurs)
|
|
MergeWith(TextChangeData(50, 50, 55, false, false));
|
|
MergeWith(TextChangeData(53, 60, 54, false, false));
|
|
MOZ_ASSERT(mStartOffset == 50,
|
|
"Test 2-1-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 55, // 60 - (55 - 50)
|
|
"Test 2-1-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 54,
|
|
"Test 2-1-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text around end of added text (becomes longer) (not sure
|
|
// if actually occurs)
|
|
MergeWith(TextChangeData(50, 50, 55, false, false));
|
|
MergeWith(TextChangeData(54, 62, 68, false, false));
|
|
MOZ_ASSERT(mStartOffset == 50,
|
|
"Test 2-2-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 57, // 62 - (55 - 50)
|
|
"Test 2-2-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 68,
|
|
"Test 2-2-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text around end of replaced text (became shorter) (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(36, 48, 45, false, false));
|
|
MergeWith(TextChangeData(43, 50, 49, false, false));
|
|
MOZ_ASSERT(mStartOffset == 36,
|
|
"Test 2-3-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 53, // 50 - (45 - 48)
|
|
"Test 2-3-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already removed text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 49,
|
|
"Test 2-3-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text around end of replaced text (became longer) (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(36, 52, 53, false, false));
|
|
MergeWith(TextChangeData(43, 68, 61, false, false));
|
|
MOZ_ASSERT(mStartOffset == 36,
|
|
"Test 2-4-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 67, // 68 - (53 - 52)
|
|
"Test 2-4-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 61,
|
|
"Test 2-4-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
/****************************************************************************
|
|
* Case 3
|
|
****************************************************************************/
|
|
|
|
// Appending text in already added text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(10, 10, 20, false, false));
|
|
MergeWith(TextChangeData(15, 15, 30, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 3-1-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 10,
|
|
"Test 3-1-2: mRemovedEndOffset should be the the first end of removed text");
|
|
MOZ_ASSERT(mAddedEndOffset == 35, // 20 + (30 - 15)
|
|
"Test 3-1-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text in added text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(50, 50, 55, false, false));
|
|
MergeWith(TextChangeData(52, 53, 56, false, false));
|
|
MOZ_ASSERT(mStartOffset == 50,
|
|
"Test 3-2-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 50,
|
|
"Test 3-2-2: mRemovedEndOffset should be the the first end of removed text");
|
|
MOZ_ASSERT(mAddedEndOffset == 58, // 55 + (56 - 53)
|
|
"Test 3-2-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text in replaced text (became shorter) (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(36, 48, 45, false, false));
|
|
MergeWith(TextChangeData(37, 38, 50, false, false));
|
|
MOZ_ASSERT(mStartOffset == 36,
|
|
"Test 3-3-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 48,
|
|
"Test 3-3-2: mRemovedEndOffset should be the the first end of removed text");
|
|
MOZ_ASSERT(mAddedEndOffset == 57, // 45 + (50 - 38)
|
|
"Test 3-3-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text in replaced text (became longer) (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(32, 48, 53, false, false));
|
|
MergeWith(TextChangeData(43, 50, 52, false, false));
|
|
MOZ_ASSERT(mStartOffset == 32,
|
|
"Test 3-4-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 48,
|
|
"Test 3-4-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 55, // 53 + (52 - 50)
|
|
"Test 3-4-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text in replaced text (became shorter) (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(36, 48, 50, false, false));
|
|
MergeWith(TextChangeData(37, 49, 47, false, false));
|
|
MOZ_ASSERT(mStartOffset == 36,
|
|
"Test 3-5-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 48,
|
|
"Test 3-5-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 48, // 50 + (47 - 49)
|
|
"Test 3-5-3: mAddedEndOffset should be the first end of added text without "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text in replaced text (became longer) (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(32, 48, 53, false, false));
|
|
MergeWith(TextChangeData(43, 50, 47, false, false));
|
|
MOZ_ASSERT(mStartOffset == 32,
|
|
"Test 3-6-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 48,
|
|
"Test 3-6-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 50, // 53 + (47 - 50)
|
|
"Test 3-6-3: mAddedEndOffset should be the first end of added text without "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
|
|
/****************************************************************************
|
|
* Case 4
|
|
****************************************************************************/
|
|
|
|
// Replacing text all of already append text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(50, 50, 55, false, false));
|
|
MergeWith(TextChangeData(44, 66, 68, false, false));
|
|
MOZ_ASSERT(mStartOffset == 44,
|
|
"Test 4-1-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 61, // 66 - (55 - 50)
|
|
"Test 4-1-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 68,
|
|
"Test 4-1-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text around a point in which text was removed (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(50, 62, 50, false, false));
|
|
MergeWith(TextChangeData(44, 66, 68, false, false));
|
|
MOZ_ASSERT(mStartOffset == 44,
|
|
"Test 4-2-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 78, // 66 - (50 - 62)
|
|
"Test 4-2-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already removed text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 68,
|
|
"Test 4-2-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text all replaced text (became shorter) (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(50, 62, 60, false, false));
|
|
MergeWith(TextChangeData(49, 128, 130, false, false));
|
|
MOZ_ASSERT(mStartOffset == 49,
|
|
"Test 4-3-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 130, // 128 - (60 - 62)
|
|
"Test 4-3-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"without already removed text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 130,
|
|
"Test 4-3-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
// Replacing text all replaced text (became longer) (not sure if actually
|
|
// occurs)
|
|
MergeWith(TextChangeData(50, 61, 73, false, false));
|
|
MergeWith(TextChangeData(44, 100, 50, false, false));
|
|
MOZ_ASSERT(mStartOffset == 44,
|
|
"Test 4-4-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 88, // 100 - (73 - 61)
|
|
"Test 4-4-2: mRemovedEndOffset should be the the last end of removed text "
|
|
"with already added text length");
|
|
MOZ_ASSERT(mAddedEndOffset == 50,
|
|
"Test 4-4-3: mAddedEndOffset should be the last end of added text");
|
|
Clear();
|
|
|
|
/****************************************************************************
|
|
* Case 5
|
|
****************************************************************************/
|
|
|
|
// Replacing text around start of added text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(50, 50, 55, false, false));
|
|
MergeWith(TextChangeData(48, 52, 49, false, false));
|
|
MOZ_ASSERT(mStartOffset == 48,
|
|
"Test 5-1-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 50,
|
|
"Test 5-1-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 52, // 55 + (52 - 49)
|
|
"Test 5-1-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text around start of replaced text (became shorter) (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(50, 60, 58, false, false));
|
|
MergeWith(TextChangeData(43, 50, 48, false, false));
|
|
MOZ_ASSERT(mStartOffset == 43,
|
|
"Test 5-2-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 60,
|
|
"Test 5-2-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 56, // 58 + (48 - 50)
|
|
"Test 5-2-3: mAddedEndOffset should be the first end of added text without "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text around start of replaced text (became longer) (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(50, 60, 68, false, false));
|
|
MergeWith(TextChangeData(43, 55, 53, false, false));
|
|
MOZ_ASSERT(mStartOffset == 43,
|
|
"Test 5-3-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 60,
|
|
"Test 5-3-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 66, // 68 + (53 - 55)
|
|
"Test 5-3-3: mAddedEndOffset should be the first end of added text without "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text around start of replaced text (became shorter) (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(50, 60, 58, false, false));
|
|
MergeWith(TextChangeData(43, 50, 128, false, false));
|
|
MOZ_ASSERT(mStartOffset == 43,
|
|
"Test 5-4-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 60,
|
|
"Test 5-4-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 136, // 58 + (128 - 50)
|
|
"Test 5-4-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text around start of replaced text (became longer) (not sure if
|
|
// actually occurs)
|
|
MergeWith(TextChangeData(50, 60, 68, false, false));
|
|
MergeWith(TextChangeData(43, 55, 65, false, false));
|
|
MOZ_ASSERT(mStartOffset == 43,
|
|
"Test 5-5-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 60,
|
|
"Test 5-5-2: mRemovedEndOffset should be the the first end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 78, // 68 + (65 - 55)
|
|
"Test 5-5-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
/****************************************************************************
|
|
* Case 6
|
|
****************************************************************************/
|
|
|
|
// Appending text before already added text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(30, 30, 45, false, false));
|
|
MergeWith(TextChangeData(10, 10, 20, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 6-1-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 30,
|
|
"Test 6-1-2: mRemovedEndOffset should be the the largest end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 55, // 45 + (20 - 10)
|
|
"Test 6-1-3: mAddedEndOffset should be the first end of added text with "
|
|
"added text length by the new change");
|
|
Clear();
|
|
|
|
// Removing text before already removed text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(30, 35, 30, false, false));
|
|
MergeWith(TextChangeData(10, 25, 10, false, false));
|
|
MOZ_ASSERT(mStartOffset == 10,
|
|
"Test 6-2-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 35,
|
|
"Test 6-2-2: mRemovedEndOffset should be the the largest end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 15, // 30 - (25 - 10)
|
|
"Test 6-2-3: mAddedEndOffset should be the first end of added text with "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text before already replaced text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(50, 65, 70, false, false));
|
|
MergeWith(TextChangeData(13, 24, 15, false, false));
|
|
MOZ_ASSERT(mStartOffset == 13,
|
|
"Test 6-3-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 65,
|
|
"Test 6-3-2: mRemovedEndOffset should be the the largest end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 61, // 70 + (15 - 24)
|
|
"Test 6-3-3: mAddedEndOffset should be the first end of added text without "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
|
|
// Replacing text before already replaced text (not sure if actually occurs)
|
|
MergeWith(TextChangeData(50, 65, 70, false, false));
|
|
MergeWith(TextChangeData(13, 24, 36, false, false));
|
|
MOZ_ASSERT(mStartOffset == 13,
|
|
"Test 6-4-1: mStartOffset should be the smallest offset");
|
|
MOZ_ASSERT(mRemovedEndOffset == 65,
|
|
"Test 6-4-2: mRemovedEndOffset should be the the largest end of removed "
|
|
"text");
|
|
MOZ_ASSERT(mAddedEndOffset == 82, // 70 + (36 - 24)
|
|
"Test 6-4-3: mAddedEndOffset should be the first end of added text without "
|
|
"removed text length by the new change");
|
|
Clear();
|
|
}
|
|
|
|
#endif // #ifdef DEBUG
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|
|
|
|
#ifdef DEBUG
|
|
//////////////////////////////////////////////////////////////
|
|
//
|
|
// Convert a GUI event message code to a string.
|
|
// Makes it a lot easier to debug events.
|
|
//
|
|
// See gtk/nsWidget.cpp and windows/nsWindow.cpp
|
|
// for a DebugPrintEvent() function that uses
|
|
// this.
|
|
//
|
|
//////////////////////////////////////////////////////////////
|
|
/* static */ nsAutoString
|
|
nsBaseWidget::debug_GuiEventToString(WidgetGUIEvent* aGuiEvent)
|
|
{
|
|
NS_ASSERTION(nullptr != aGuiEvent,"cmon, null gui event.");
|
|
|
|
nsAutoString eventName(NS_LITERAL_STRING("UNKNOWN"));
|
|
|
|
#define _ASSIGN_eventName(_value,_name)\
|
|
case _value: eventName.AssignLiteral(_name) ; break
|
|
|
|
switch(aGuiEvent->mMessage)
|
|
{
|
|
_ASSIGN_eventName(eBlur,"eBlur");
|
|
_ASSIGN_eventName(eDrop,"eDrop");
|
|
_ASSIGN_eventName(eDragEnter,"eDragEnter");
|
|
_ASSIGN_eventName(eDragExit,"eDragExit");
|
|
_ASSIGN_eventName(eDragOver,"eDragOver");
|
|
_ASSIGN_eventName(eEditorInput,"eEditorInput");
|
|
_ASSIGN_eventName(eFocus,"eFocus");
|
|
_ASSIGN_eventName(eFocusIn,"eFocusIn");
|
|
_ASSIGN_eventName(eFocusOut,"eFocusOut");
|
|
_ASSIGN_eventName(eFormSelect,"eFormSelect");
|
|
_ASSIGN_eventName(eFormChange,"eFormChange");
|
|
_ASSIGN_eventName(eFormReset,"eFormReset");
|
|
_ASSIGN_eventName(eFormSubmit,"eFormSubmit");
|
|
_ASSIGN_eventName(eImageAbort,"eImageAbort");
|
|
_ASSIGN_eventName(eLoadError,"eLoadError");
|
|
_ASSIGN_eventName(eKeyDown,"eKeyDown");
|
|
_ASSIGN_eventName(eKeyPress,"eKeyPress");
|
|
_ASSIGN_eventName(eKeyUp,"eKeyUp");
|
|
_ASSIGN_eventName(eMouseEnterIntoWidget,"eMouseEnterIntoWidget");
|
|
_ASSIGN_eventName(eMouseExitFromWidget,"eMouseExitFromWidget");
|
|
_ASSIGN_eventName(eMouseDown,"eMouseDown");
|
|
_ASSIGN_eventName(eMouseUp,"eMouseUp");
|
|
_ASSIGN_eventName(eMouseClick,"eMouseClick");
|
|
_ASSIGN_eventName(eMouseDoubleClick,"eMouseDoubleClick");
|
|
_ASSIGN_eventName(eMouseMove,"eMouseMove");
|
|
_ASSIGN_eventName(eLoad,"eLoad");
|
|
_ASSIGN_eventName(ePopState,"ePopState");
|
|
_ASSIGN_eventName(eBeforeScriptExecute,"eBeforeScriptExecute");
|
|
_ASSIGN_eventName(eAfterScriptExecute,"eAfterScriptExecute");
|
|
_ASSIGN_eventName(eUnload,"eUnload");
|
|
_ASSIGN_eventName(eHashChange,"eHashChange");
|
|
_ASSIGN_eventName(eReadyStateChange,"eReadyStateChange");
|
|
_ASSIGN_eventName(eXULBroadcast, "eXULBroadcast");
|
|
_ASSIGN_eventName(eXULCommandUpdate, "eXULCommandUpdate");
|
|
|
|
#undef _ASSIGN_eventName
|
|
|
|
default:
|
|
{
|
|
char buf[32];
|
|
|
|
SprintfLiteral(buf,"UNKNOWN: %d",aGuiEvent->mMessage);
|
|
|
|
CopyASCIItoUTF16(buf, eventName);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return nsAutoString(eventName);
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
//
|
|
// Code to deal with paint and event debug prefs.
|
|
//
|
|
//////////////////////////////////////////////////////////////
|
|
struct PrefPair
|
|
{
|
|
const char * name;
|
|
bool value;
|
|
};
|
|
|
|
static PrefPair debug_PrefValues[] =
|
|
{
|
|
{ "nglayout.debug.crossing_event_dumping", false },
|
|
{ "nglayout.debug.event_dumping", false },
|
|
{ "nglayout.debug.invalidate_dumping", false },
|
|
{ "nglayout.debug.motion_event_dumping", false },
|
|
{ "nglayout.debug.paint_dumping", false },
|
|
{ "nglayout.debug.paint_flashing", false }
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
bool
|
|
nsBaseWidget::debug_GetCachedBoolPref(const char * aPrefName)
|
|
{
|
|
NS_ASSERTION(nullptr != aPrefName,"cmon, pref name is null.");
|
|
|
|
for (uint32_t i = 0; i < ArrayLength(debug_PrefValues); i++)
|
|
{
|
|
if (strcmp(debug_PrefValues[i].name, aPrefName) == 0)
|
|
{
|
|
return debug_PrefValues[i].value;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
static void debug_SetCachedBoolPref(const char * aPrefName,bool aValue)
|
|
{
|
|
NS_ASSERTION(nullptr != aPrefName,"cmon, pref name is null.");
|
|
|
|
for (uint32_t i = 0; i < ArrayLength(debug_PrefValues); i++)
|
|
{
|
|
if (strcmp(debug_PrefValues[i].name, aPrefName) == 0)
|
|
{
|
|
debug_PrefValues[i].value = aValue;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
NS_ASSERTION(false, "cmon, this code is not reached dude.");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
class Debug_PrefObserver final : public nsIObserver {
|
|
~Debug_PrefObserver() {}
|
|
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIOBSERVER
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(Debug_PrefObserver, nsIObserver)
|
|
|
|
NS_IMETHODIMP
|
|
Debug_PrefObserver::Observe(nsISupports* subject, const char* topic,
|
|
const char16_t* data)
|
|
{
|
|
NS_ConvertUTF16toUTF8 prefName(data);
|
|
|
|
bool value = Preferences::GetBool(prefName.get(), false);
|
|
debug_SetCachedBoolPref(prefName.get(), value);
|
|
return NS_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
/* static */ void
|
|
debug_RegisterPrefCallbacks()
|
|
{
|
|
static bool once = true;
|
|
|
|
if (!once) {
|
|
return;
|
|
}
|
|
|
|
once = false;
|
|
|
|
nsCOMPtr<nsIObserver> obs(new Debug_PrefObserver());
|
|
for (uint32_t i = 0; i < ArrayLength(debug_PrefValues); i++) {
|
|
// Initialize the pref values
|
|
debug_PrefValues[i].value =
|
|
Preferences::GetBool(debug_PrefValues[i].name, false);
|
|
|
|
if (obs) {
|
|
// Register callbacks for when these change
|
|
Preferences::AddStrongObserver(obs, debug_PrefValues[i].name);
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
static int32_t
|
|
_GetPrintCount()
|
|
{
|
|
static int32_t sCount = 0;
|
|
|
|
return ++sCount;
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
/* static */ bool
|
|
nsBaseWidget::debug_WantPaintFlashing()
|
|
{
|
|
return debug_GetCachedBoolPref("nglayout.debug.paint_flashing");
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
/* static */ void
|
|
nsBaseWidget::debug_DumpEvent(FILE * aFileOut,
|
|
nsIWidget * aWidget,
|
|
WidgetGUIEvent* aGuiEvent,
|
|
const char* aWidgetName,
|
|
int32_t aWindowID)
|
|
{
|
|
if (aGuiEvent->mMessage == eMouseMove) {
|
|
if (!debug_GetCachedBoolPref("nglayout.debug.motion_event_dumping"))
|
|
return;
|
|
}
|
|
|
|
if (aGuiEvent->mMessage == eMouseEnterIntoWidget ||
|
|
aGuiEvent->mMessage == eMouseExitFromWidget) {
|
|
if (!debug_GetCachedBoolPref("nglayout.debug.crossing_event_dumping"))
|
|
return;
|
|
}
|
|
|
|
if (!debug_GetCachedBoolPref("nglayout.debug.event_dumping"))
|
|
return;
|
|
|
|
NS_LossyConvertUTF16toASCII tempString(debug_GuiEventToString(aGuiEvent).get());
|
|
|
|
fprintf(aFileOut,
|
|
"%4d %-26s widget=%-8p name=%-12s id=0x%-6x refpt=%d,%d\n",
|
|
_GetPrintCount(),
|
|
tempString.get(),
|
|
(void *) aWidget,
|
|
aWidgetName,
|
|
aWindowID,
|
|
aGuiEvent->mRefPoint.x,
|
|
aGuiEvent->mRefPoint.y);
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
/* static */ void
|
|
nsBaseWidget::debug_DumpPaintEvent(FILE * aFileOut,
|
|
nsIWidget * aWidget,
|
|
const nsIntRegion & aRegion,
|
|
const char * aWidgetName,
|
|
int32_t aWindowID)
|
|
{
|
|
NS_ASSERTION(nullptr != aFileOut,"cmon, null output FILE");
|
|
NS_ASSERTION(nullptr != aWidget,"cmon, the widget is null");
|
|
|
|
if (!debug_GetCachedBoolPref("nglayout.debug.paint_dumping"))
|
|
return;
|
|
|
|
nsIntRect rect = aRegion.GetBounds();
|
|
fprintf(aFileOut,
|
|
"%4d PAINT widget=%p name=%-12s id=0x%-6x bounds-rect=%3d,%-3d %3d,%-3d",
|
|
_GetPrintCount(),
|
|
(void *) aWidget,
|
|
aWidgetName,
|
|
aWindowID,
|
|
rect.x, rect.y, rect.width, rect.height
|
|
);
|
|
|
|
fprintf(aFileOut,"\n");
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
/* static */ void
|
|
nsBaseWidget::debug_DumpInvalidate(FILE* aFileOut,
|
|
nsIWidget* aWidget,
|
|
const LayoutDeviceIntRect* aRect,
|
|
const char* aWidgetName,
|
|
int32_t aWindowID)
|
|
{
|
|
if (!debug_GetCachedBoolPref("nglayout.debug.invalidate_dumping"))
|
|
return;
|
|
|
|
NS_ASSERTION(nullptr != aFileOut,"cmon, null output FILE");
|
|
NS_ASSERTION(nullptr != aWidget,"cmon, the widget is null");
|
|
|
|
fprintf(aFileOut,
|
|
"%4d Invalidate widget=%p name=%-12s id=0x%-6x",
|
|
_GetPrintCount(),
|
|
(void *) aWidget,
|
|
aWidgetName,
|
|
aWindowID);
|
|
|
|
if (aRect) {
|
|
fprintf(aFileOut,
|
|
" rect=%3d,%-3d %3d,%-3d",
|
|
aRect->x, aRect->y, aRect->width, aRect->height);
|
|
} else {
|
|
fprintf(aFileOut,
|
|
" rect=%-15s",
|
|
"none");
|
|
}
|
|
|
|
fprintf(aFileOut, "\n");
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
#endif // DEBUG
|