/* -*- 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 "nsBaseWidget.h"

#include <utility>

#include "GLConsts.h"

#include "InputData.h"

#include "LiveResizeListener.h"

#include "TouchEvents.h"

#include "WritingModes.h"

#include "X11UndefineNone.h"

#include "base/thread.h"

#include "mozilla/ArrayUtils.h"

#include "mozilla/Attributes.h"

#include "mozilla/GlobalKeyListener.h"

#include "mozilla/IMEStateManager.h"

#include "mozilla/MouseEvents.h"

#include "mozilla/Preferences.h"

#include "mozilla/PresShell.h"

#include "mozilla/Sprintf.h"

#include "mozilla/StaticPrefs_apz.h"

#include "mozilla/StaticPrefs_dom.h"

#include "mozilla/StaticPrefs_gfx.h"

#include "mozilla/StaticPrefs_layers.h"

#include "mozilla/StaticPrefs_layout.h"

#include "mozilla/TextEventDispatcher.h"

#include "mozilla/TextEventDispatcherListener.h"

#include "mozilla/UniquePtr.h"

#include "mozilla/Unused.h"

#include "mozilla/VsyncDispatcher.h"

#include "mozilla/dom/BrowserParent.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/Document.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/gfx/GPUProcessManager.h"

#include "mozilla/gfx/gfxVars.h"

#include "mozilla/layers/APZCCallbackHelper.h"

#include "mozilla/layers/APZEventState.h"

#include "mozilla/layers/APZInputBridge.h"

#include "mozilla/layers/APZThreadUtils.h"

#include "mozilla/layers/ChromeProcessController.h"

#include "mozilla/layers/Compositor.h"

#include "mozilla/layers/CompositorBridgeChild.h"

#include "mozilla/layers/CompositorBridgeParent.h"

#include "mozilla/layers/CompositorOptions.h"

#include "mozilla/layers/IAPZCTreeManager.h"

#include "mozilla/layers/ImageBridgeChild.h"

#include "mozilla/layers/InputAPZContext.h"

#include "mozilla/layers/WebRenderLayerManager.h"

#include "mozilla/webrender/WebRenderTypes.h"

#include "nsAppDirectoryServiceDefs.h"

#include "nsCOMPtr.h"

#include "nsContentUtils.h"

#include "nsDeviceContext.h"

#include "nsGfxCIID.h"

#include "nsIAppWindow.h"

#include "nsIBaseWindow.h"

#include "nsIContent.h"

#include "nsIScreenManager.h"

#include "nsISimpleEnumerator.h"

#include "nsIWidgetListener.h"

#include "nsRefPtrHashtable.h"

#include "nsServiceManagerUtils.h"

#include "nsWidgetsCID.h"

#include "nsXULPopupManager.h"

#include "prdtoa.h"

#include "prenv.h"

#ifdef ACCESSIBILITY

#  include "nsAccessibilityService.h"

#endif

#include "gfxConfig.h"

#include "gfxUtils.h"  // for ToDeviceColor

#include "mozilla/layers/CompositorSession.h"

#include "VRManagerChild.h"

#include "gfxConfig.h"

#include "nsView.h"

#include "nsViewManager.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;

// 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*/ nsTHashMap<uint64_t, nsCOMPtr<nsIObserver>>

    AutoObserverNotifier::sSavedObservers;

// The maximum amount of time to let the EnableDragDrop runnable wait in the

// idle queue before timing out and moving it to the regular queue. Value is in

// milliseconds.

const uint32_t kAsyncDragDropTimeout = 1000;

namespace mozilla::widget {

void IMENotification::SelectionChangeDataBase::SetWritingMode(

    const WritingMode& aWritingMode) {

  mWritingMode = aWritingMode.mWritingMode.bits;

}

WritingMode IMENotification::SelectionChangeDataBase::GetWritingMode() const {

  return WritingMode(mWritingMode);

}

}  // namespace mozilla::widget

NS_IMPL_ISUPPORTS(nsBaseWidget, nsIWidget, nsISupportsWeakReference)

//-------------------------------------------------------------------------

//

// nsBaseWidget constructor

//

//-------------------------------------------------------------------------

nsBaseWidget::nsBaseWidget()

    : mWidgetListener(nullptr),

      mAttachedWidgetListener(nullptr),

      mPreviouslyAttachedWidgetListener(nullptr),

      mCompositorVsyncDispatcher(nullptr),

      mBorderStyle(eBorderStyle_none),

      mBounds(0, 0, 0, 0),

      mOriginalBounds(nullptr),

      mClipRectCount(0),

      mSizeMode(nsSizeMode_Normal),

      mIsTiled(false),

      mPopupLevel(ePopupLevelTop),

      mPopupType(ePopupTypeAny),

      mHasRemoteContent(false),

      mFissionWindow(false),

      mUpdateCursor(true),

      mUseAttachedEvents(false),

      mIMEHasFocus(false),

      mIMEHasQuit(false),

      mIsFullyOccluded(false) {

#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) {

    return NS_OK;

  }

  if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {

    RefPtr<nsBaseWidget> widget(mWidget);

    widget->Shutdown();

  } else if (!strcmp(aTopic, "quit-application")) {

    RefPtr<nsBaseWidget> widget(mWidget);

    widget->QuitIME();

  }

  return NS_OK;

}

void WidgetShutdownObserver::Register() {

  if (!mRegistered) {

    mRegistered = true;

    nsContentUtils::RegisterShutdownObserver(this);

#ifndef MOZ_WIDGET_ANDROID

    // The primary purpose of observing quit-application is

    // to avoid leaking a widget on Windows when nothing else

    // breaks the circular reference between the widget and

    // TSFTextStore. However, our Android IME code crashes if

    // doing this on Android, so let's not do this on Android.

    // Doing this on Gtk and Mac just in case.

    nsCOMPtr<nsIObserverService> observerService =

        mozilla::services::GetObserverService();

    if (observerService) {

      observerService->AddObserver(this, "quit-application", false);

    }

#endif

  }

}

void WidgetShutdownObserver::Unregister() {

  if (mRegistered) {

    mWidget = nullptr;

#ifndef MOZ_WIDGET_ANDROID

    nsCOMPtr<nsIObserverService> observerService =

        mozilla::services::GetObserverService();

    if (observerService) {

      observerService->RemoveObserver(this, "quit-application");

    }

#endif

    nsContentUtils::UnregisterShutdownObserver(this);

    mRegistered = false;

  }

}

#define INTL_APP_LOCALES_CHANGED "intl:app-locales-changed"

#define L10N_PSEUDO_PREF "intl.l10n.pseudo"

static const char* kObservedPrefs[] = {L10N_PSEUDO_PREF, nullptr};

NS_IMPL_ISUPPORTS(LocalesChangedObserver, nsIObserver)

LocalesChangedObserver::LocalesChangedObserver(nsBaseWidget* aWidget)

    : mWidget(aWidget), mRegistered(false) {

  Register();

}

LocalesChangedObserver::~LocalesChangedObserver() {

  // 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

LocalesChangedObserver::Observe(nsISupports* aSubject, const char* aTopic,

                                const char16_t* aData) {

  if (!mWidget) {

    return NS_OK;

  }

  if (!strcmp(aTopic, INTL_APP_LOCALES_CHANGED)) {

    RefPtr<nsBaseWidget> widget(mWidget);

    widget->LocalesChanged();

  } else {

    MOZ_ASSERT(!strcmp("nsPref:changed", aTopic));

    nsDependentString pref(aData);

    if (pref.EqualsLiteral(L10N_PSEUDO_PREF)) {

      RefPtr<nsBaseWidget> widget(mWidget);

      widget->LocalesChanged();

    }

  }

  return NS_OK;

}

void LocalesChangedObserver::Register() {

  if (mRegistered) {

    return;

  }

  DebugOnly<nsresult> rv =

      Preferences::AddStrongObservers(this, kObservedPrefs);

  MOZ_ASSERT(NS_SUCCEEDED(rv), "Adding observers failed.");

  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();

  if (obs) {

    obs->AddObserver(this, INTL_APP_LOCALES_CHANGED, true);

  }

  // Locale might be update before registering

  RefPtr<nsBaseWidget> widget(mWidget);

  widget->LocalesChanged();

  mRegistered = true;

}

void LocalesChangedObserver::Unregister() {

  if (!mRegistered) {

    return;

  }

  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();

  if (obs) {

    obs->RemoveObserver(this, INTL_APP_LOCALES_CHANGED);

  }

  Preferences::RemoveObservers(this, kObservedPrefs);

  mWidget = nullptr;

  mRegistered = false;

}