/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

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

#ifndef nsBaseWidget_h__

#define nsBaseWidget_h__

#include "InputData.h"

#include "mozilla/EventForwards.h"

#include "mozilla/Mutex.h"

#include "mozilla/RefPtr.h"

#include "mozilla/UniquePtr.h"

#include "mozilla/WidgetUtils.h"

#include "mozilla/dom/MouseEventBinding.h"

#include "mozilla/layers/APZCCallbackHelper.h"

#include "mozilla/layers/CompositorOptions.h"

#include "mozilla/layers/NativeLayer.h"

#include "mozilla/widget/ThemeChangeKind.h"

#include "nsRect.h"

#include "nsIWidget.h"

#include "nsWidgetsCID.h"

#include "nsIFile.h"

#include "nsString.h"

#include "nsCOMPtr.h"

#include "nsIRollupListener.h"

#include "nsIObserver.h"

#include "nsIWidgetListener.h"

#include "nsPIDOMWindow.h"

#include "nsWeakReference.h"

#include <algorithm>

#if defined(XP_WIN)

// Scroll capture constants

const uint32_t kScrollCaptureFillColor = 0xFFa0a0a0;  // gray

const mozilla::gfx::SurfaceFormat kScrollCaptureFormat =

    mozilla::gfx::SurfaceFormat::X8R8G8B8_UINT32;

#endif

class nsIContent;

class gfxContext;

namespace mozilla {

class CompositorVsyncDispatcher;

class LiveResizeListener;

class FallbackRenderer;

#ifdef ACCESSIBILITY

namespace a11y {

class LocalAccessible;

}

#endif

namespace gfx {

class DrawTarget;

class SourceSurface;

}  // namespace gfx

namespace layers {

class CompositorBridgeChild;

class CompositorBridgeParent;

class IAPZCTreeManager;

class GeckoContentController;

class APZEventState;

struct APZEventResult;

class CompositorSession;

class ImageContainer;

struct ScrollableLayerGuid;

class RemoteCompositorSession;

}  // namespace layers

namespace widget {

class CompositorWidgetDelegate;

class InProcessCompositorWidget;

class WidgetRenderingContext;

}  // namespace widget

class CompositorVsyncDispatcher;

}  // namespace mozilla

namespace base {

class Thread;

}  // namespace base

// Windows specific constant indicating the maximum number of touch points the

// inject api will allow. This also sets the maximum numerical value for touch

// ids we can use when injecting touch points on Windows.

#define TOUCH_INJECT_MAX_POINTS 256

class nsBaseWidget;

// Helper class used in shutting down gfx related code.

class WidgetShutdownObserver final : public nsIObserver {

  ~WidgetShutdownObserver();

 public:

  explicit WidgetShutdownObserver(nsBaseWidget* aWidget);

  NS_DECL_ISUPPORTS

  NS_DECL_NSIOBSERVER

  void Register();

  void Unregister();

  nsBaseWidget* mWidget;

  bool mRegistered;

};

// Helper class used for observing locales change.

class LocalesChangedObserver final : public nsIObserver {

  ~LocalesChangedObserver();

 public:

  explicit LocalesChangedObserver(nsBaseWidget* aWidget);

  NS_DECL_ISUPPORTS

  NS_DECL_NSIOBSERVER

  void Register();

  void Unregister();

  nsBaseWidget* mWidget;

  bool mRegistered;

};

/**

 * Common widget implementation used as base class for native

 * or crossplatform implementations of Widgets.

 * All cross-platform behavior that all widgets need to implement

 * should be placed in this class.

 * (Note: widget implementations are not required to use this

 * class, but it gives them a head start.)

 */

class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {

  template <class EventType, class InputType>

  friend class DispatchEventOnMainThread;

  friend class mozilla::widget::InProcessCompositorWidget;

  friend class mozilla::layers::RemoteCompositorSession;

 protected:

  typedef base::Thread Thread;

  typedef mozilla::gfx::DrawTarget DrawTarget;

  typedef mozilla::gfx::SourceSurface SourceSurface;

  typedef mozilla::layers::BufferMode BufferMode;

  typedef mozilla::layers::CompositorBridgeChild CompositorBridgeChild;

  typedef mozilla::layers::CompositorBridgeParent CompositorBridgeParent;

  typedef mozilla::layers::IAPZCTreeManager IAPZCTreeManager;

  typedef mozilla::layers::GeckoContentController GeckoContentController;

  typedef mozilla::layers::ScrollableLayerGuid ScrollableLayerGuid;

  typedef mozilla::layers::APZEventState APZEventState;

  typedef mozilla::layers::SetAllowedTouchBehaviorCallback

      SetAllowedTouchBehaviorCallback;

  typedef mozilla::CSSIntRect CSSIntRect;

  typedef mozilla::CSSRect CSSRect;

  typedef mozilla::ScreenRotation ScreenRotation;

  typedef mozilla::widget::CompositorWidgetDelegate CompositorWidgetDelegate;

  typedef mozilla::layers::CompositorSession CompositorSession;

  typedef mozilla::layers::ImageContainer ImageContainer;

  virtual ~nsBaseWidget();

 public:

  nsBaseWidget();

  NS_DECL_THREADSAFE_ISUPPORTS

  // nsIWidget interface

  void CaptureMouse(bool aCapture) override {}

  void CaptureRollupEvents(nsIRollupListener* aListener,

                           bool aDoCapture) override {}

  nsIWidgetListener* GetWidgetListener() override;

  void SetWidgetListener(nsIWidgetListener* alistener) override;

  void Destroy() override;

  void SetParent(nsIWidget* aNewParent) override{};

  nsIWidget* GetParent() override;

  nsIWidget* GetTopLevelWidget() override;

  nsIWidget* GetSheetWindowParent(void) override;

  float GetDPI() override;

  void AddChild(nsIWidget* aChild) override;

  void RemoveChild(nsIWidget* aChild) override;

  void SetZIndex(int32_t aZIndex) override;

  void PlaceBehind(nsTopLevelWidgetZPlacement aPlacement, nsIWidget* aWidget,

                   bool aActivate) override {}

  void SetSizeMode(nsSizeMode aMode) override;

  nsSizeMode SizeMode() override { return mSizeMode; }

  void GetWorkspaceID(nsAString& workspaceID) override;

  void MoveToWorkspace(const nsAString& workspaceID) override;

  bool IsTiled() const override { return mIsTiled; }

  bool IsFullyOccluded() const override { return mIsFullyOccluded; }

  void SetCursor(const Cursor&) override;

  void ClearCachedCursor() final {

    mCursor = {};

    mUpdateCursor = true;

  }

  void SetTransparencyMode(nsTransparencyMode aMode) override;

  nsTransparencyMode GetTransparencyMode() override;

  void GetWindowClipRegion(nsTArray<LayoutDeviceIntRect>* aRects) override;

  void SetWindowShadowStyle(mozilla::StyleWindowShadow aStyle) override {}

  void SetShowsToolbarButton(bool aShow) override {}

  void SetSupportsNativeFullscreen(bool aSupportsNativeFullscreen) override {}

  void SetWindowAnimationType(WindowAnimationType aType) override {}

  void HideWindowChrome(bool aShouldHide) override {}

  bool PrepareForFullscreenTransition(nsISupports** aData) override {

    return false;

  }

  void PerformFullscreenTransition(FullscreenTransitionStage aStage,

                                   uint16_t aDuration, nsISupports* aData,

                                   nsIRunnable* aCallback) override;

  void CleanupFullscreenTransition() override {}

  already_AddRefed<nsIScreen> GetWidgetScreen() override;

  nsresult MakeFullScreen(bool aFullScreen,

                          nsIScreen* aScreen = nullptr) override;

  void InfallibleMakeFullScreen(bool aFullScreen, nsIScreen* aScreen = nullptr);

  WindowRenderer* GetWindowRenderer() override;

  // A remote compositor session tied to this window has been lost and IPC

  // messages will no longer work. The widget must clean up any lingering

  // resources and possibly schedule another paint.

  //

  // A reference to the session object is held until this function has

  // returned.

  void NotifyCompositorSessionLost(

      mozilla::layers::CompositorSession* aSession);

  already_AddRefed<mozilla::CompositorVsyncDispatcher>

  GetCompositorVsyncDispatcher();

  virtual void CreateCompositorVsyncDispatcher();

  virtual void CreateCompositor();

  virtual void CreateCompositor(int aWidth, int aHeight);

  virtual void SetCompositorWidgetDelegate(CompositorWidgetDelegate*) {}

  void PrepareWindowEffects() override {}

  void UpdateThemeGeometries(

      const nsTArray<ThemeGeometry>& aThemeGeometries) override {}

  void SetModal(bool aModal) override {}

  uint32_t GetMaxTouchPoints() const override;

  void SetWindowClass(const nsAString& xulWinType) override {}

  nsresult SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,

                               bool aIntersectWithExisting) override;

  // Return whether this widget interprets parameters to Move and Resize APIs

  // as "desktop pixels" rather than "device pixels", and therefore

  // applies its GetDefaultScale() value to them before using them as mBounds

  // etc (which are always stored in device pixels).

  // Note that APIs that -get- the widget's position/size/bounds, rather than

  // -setting- them (i.e. moving or resizing the widget) will always return

  // values in the widget's device pixels.

  bool BoundsUseDesktopPixels() const {

    return mWindowType <= eWindowType_popup;

  }

  // Default implementation, to be overridden by platforms where desktop coords

  // are virtualized and may not correspond to device pixels on the screen.

  mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() override {

    return mozilla::DesktopToLayoutDeviceScale(1.0);

  }

  mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScaleByScreen()

      override;

  void ConstrainPosition(bool aAllowSlop, int32_t* aX, int32_t* aY) override {}

  void MoveClient(const DesktopPoint& aOffset) override;

  void ResizeClient(const DesktopSize& aSize, bool aRepaint) override;

  void ResizeClient(const DesktopRect& aRect, bool aRepaint) override;

  LayoutDeviceIntRect GetBounds() override;

  LayoutDeviceIntRect GetClientBounds() override;

  LayoutDeviceIntRect GetScreenBounds() override;

  [[nodiscard]] nsresult GetRestoredBounds(LayoutDeviceIntRect& aRect) override;

  nsresult SetNonClientMargins(LayoutDeviceIntMargin& aMargins) override;

  LayoutDeviceIntPoint GetClientOffset() override;

  void EnableDragDrop(bool aEnable) override{};

  nsresult AsyncEnableDragDrop(bool aEnable) override;

  [[nodiscard]] nsresult GetAttention(int32_t aCycleCount) override {

    return NS_OK;

  }

  bool HasPendingInputEvent() override;

  void SetIcon(const nsAString& aIconSpec) override {}

  void SetDrawsInTitlebar(bool aState) override {}

  bool ShowsResizeIndicator(LayoutDeviceIntRect* aResizerRect) override;

  void FreeNativeData(void* data, uint32_t aDataType) override {}

  [[nodiscard]] nsresult BeginResizeDrag(mozilla::WidgetGUIEvent* aEvent,

                                         int32_t aHorizontal,

                                         int32_t aVertical) override {

    return NS_ERROR_NOT_IMPLEMENTED;

  }

  nsresult ActivateNativeMenuItemAt(const nsAString& indexString) override {

    return NS_ERROR_NOT_IMPLEMENTED;

  }

  nsresult ForceUpdateNativeMenuAt(const nsAString& indexString) override {

    return NS_ERROR_NOT_IMPLEMENTED;

  }

  nsresult NotifyIME(const IMENotification& aIMENotification) final;

  [[nodiscard]] nsresult AttachNativeKeyEvent(

      mozilla::WidgetKeyboardEvent& aEvent) override {

    return NS_ERROR_NOT_IMPLEMENTED;

  }

  bool ComputeShouldAccelerate();

  virtual bool WidgetTypeSupportsAcceleration() { return true; }

  [[nodiscard]] nsresult OnDefaultButtonLoaded(

      const LayoutDeviceIntRect& aButtonRect) override {

    return NS_ERROR_NOT_IMPLEMENTED;

  }

  already_AddRefed<nsIWidget> CreateChild(

      const LayoutDeviceIntRect& aRect, nsWidgetInitData* aInitData = nullptr,

      bool aForceUseIWidgetParent = false) override;

  void AttachViewToTopLevel(bool aUseAttachedEvents) override;

  nsIWidgetListener* GetAttachedWidgetListener() override;

  void SetAttachedWidgetListener(nsIWidgetListener* aListener) override;