gecko-dev/widget/nsIWidget.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2128 lines
74 KiB
C
Raw Normal View History

/* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2015-01-22 04:35:17 +00:00
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsIWidget_h__
#define nsIWidget_h__
#include <cmath>
#include <cstdint>
#include "ErrorList.h"
#include "Units.h"
#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
2015-01-22 04:35:17 +00:00
#include "mozilla/EventForwards.h"
#include "mozilla/Maybe.h"
Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat The bulk of this commit was generated with a script, executed at the top level of a typical source code checkout. The only non-machine-generated part was modifying MFBT's moz.build to reflect the new naming. CLOSED TREE makes big refactorings like this a piece of cake. # The main substitution. find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \ xargs perl -p -i -e ' s/nsRefPtr\.h/RefPtr\.h/g; # handle includes s/nsRefPtr ?</RefPtr</g; # handle declarations and variables ' # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h. perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h # Handle nsRefPtr.h itself, a couple places that define constructors # from nsRefPtr, and code generators specially. We do this here, rather # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename # things like nsRefPtrHashtable. perl -p -i -e 's/nsRefPtr/RefPtr/g' \ mfbt/nsRefPtr.h \ xpcom/glue/nsCOMPtr.h \ xpcom/base/OwningNonNull.h \ ipc/ipdl/ipdl/lower.py \ ipc/ipdl/ipdl/builtin.py \ dom/bindings/Codegen.py \ python/lldbutils/lldbutils/utils.py # In our indiscriminate substitution above, we renamed # nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up. find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \ xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g' if [ -d .git ]; then git mv mfbt/nsRefPtr.h mfbt/RefPtr.h else hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h fi --HG-- rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 05:24:48 +00:00
#include "mozilla/RefPtr.h"
2015-01-22 04:35:17 +00:00
#include "mozilla/TimeStamp.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/gfx/Matrix.h"
#include "mozilla/gfx/Rect.h"
#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/ScrollableLayerGuid.h"
#include "mozilla/layers/ZoomConstraints.h"
#include "mozilla/image/Resolution.h"
#include "mozilla/widget/IMEData.h"
#include "nsCOMPtr.h"
#include "nsColor.h"
#include "nsDebug.h"
#include "nsID.h"
#include "nsIObserver.h"
#include "nsISupports.h"
#include "nsITheme.h"
#include "nsITimer.h"
#include "nsIWidgetListener.h"
#include "nsRect.h"
#include "nsSize.h"
#include "nsStringFwd.h"
#include "nsTArray.h"
#include "nsTHashMap.h"
#include "nsWidgetInitData.h"
#include "nsXULAppAPI.h"
2015-01-22 04:35:17 +00:00
#ifdef MOZ_IS_GCC
# include "VsyncSource.h"
#endif
2015-01-22 04:35:17 +00:00
// forward declarations
class nsIBidiKeyboard;
2015-01-22 04:35:17 +00:00
class nsIRollupListener;
class imgIContainer;
class nsIContent;
class ViewWrapper;
class nsIScreen;
class nsIRunnable;
2015-01-22 04:35:17 +00:00
namespace mozilla {
class NativeEventData;
class WidgetGUIEvent;
class WidgetInputEvent;
class WidgetKeyboardEvent;
struct FontRange;
enum class StyleWindowShadow : uint8_t;
enum class ColorScheme : uint8_t;
#if defined(MOZ_WIDGET_ANDROID)
namespace ipc {
class Shmem;
}
#endif // defined(MOZ_WIDGET_ANDROID)
2015-01-22 04:35:17 +00:00
namespace dom {
class BrowserChild;
enum class CallerType : uint32_t;
} // namespace dom
class WindowRenderer;
2015-01-22 04:35:17 +00:00
namespace layers {
class AsyncDragMetrics;
class Compositor;
class CompositorBridgeChild;
struct FrameMetrics;
2015-01-22 04:35:17 +00:00
class LayerManager;
class WebRenderBridgeChild;
} // namespace layers
2015-01-22 04:35:17 +00:00
namespace gfx {
class VsyncSource;
} // namespace gfx
namespace widget {
class TextEventDispatcher;
class TextEventDispatcherListener;
class CompositorWidget;
class CompositorWidgetInitData;
} // namespace widget
namespace wr {
class DisplayListBuilder;
class IpcResourceUpdateQueue;
enum class RenderRoot : uint8_t;
} // namespace wr
} // namespace mozilla
2015-01-22 04:35:17 +00:00
/**
* Callback function that processes events.
*
* The argument is actually a subtype (subclass) of WidgetEvent which carries
* platform specific information about the event. Platform specific code
* knows how to deal with it.
*
* The return value determines whether or not the default action should take
* place.
*/
typedef nsEventStatus (*EVENT_CALLBACK)(mozilla::WidgetGUIEvent* aEvent);
// Hide the native window system's real window type so as to avoid
// including native window system types and APIs. This is necessary
// to ensure cross-platform code.
typedef void* nsNativeWidget;
/**
* Flags for the GetNativeData and SetNativeData functions
2015-01-22 04:35:17 +00:00
*/
#define NS_NATIVE_WINDOW 0
#define NS_NATIVE_GRAPHIC 1
#define NS_NATIVE_TMP_WINDOW 2
#define NS_NATIVE_WIDGET 3
#define NS_NATIVE_DISPLAY 4
#define NS_NATIVE_REGION 5
#define NS_NATIVE_OFFSETX 6
#define NS_NATIVE_OFFSETY 7
#define NS_NATIVE_SCREEN 9
// The toplevel GtkWidget containing this nsIWidget:
#define NS_NATIVE_SHELLWIDGET 10
#define NS_NATIVE_OPENGL_CONTEXT 12
// This is available only with GetNativeData() in parent process. Anybody
// shouldn't access this pointer as a valid pointer since the result may be
// special value like NS_ONLY_ONE_NATIVE_IME_CONTEXT. So, the result is just
// an identifier of distinguishing a text composition is caused by which native
// IME context. Note that the result is only valid in the process. So,
// XP code should use nsIWidget::GetNativeIMEContext() instead of using this.
#define NS_RAW_NATIVE_IME_CONTEXT 14
#define NS_NATIVE_WINDOW_WEBRTC_DEVICE_ID 15
2015-01-22 04:35:17 +00:00
#ifdef XP_WIN
# define NS_NATIVE_TSF_THREAD_MGR 100
# define NS_NATIVE_TSF_CATEGORY_MGR 101
# define NS_NATIVE_TSF_DISPLAY_ATTR_MGR 102
# define NS_NATIVE_ICOREWINDOW 103 // winrt specific
#endif
#if defined(MOZ_WIDGET_GTK)
# define NS_NATIVE_EGL_WINDOW 106
#endif
#ifdef MOZ_WIDGET_ANDROID
# define NS_JAVA_SURFACE 100
# define NS_PRESENTATION_WINDOW 101
# define NS_PRESENTATION_SURFACE 102
#endif
2015-01-22 04:35:17 +00:00
#define MOZ_WIDGET_MAX_SIZE 16384
#define MOZ_WIDGET_INVALID_SCALE 0.0
// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/nonidl.rs
2015-01-22 04:35:17 +00:00
#define NS_IWIDGET_IID \
{ \
0x06396bf6, 0x2dd8, 0x45e5, { \
0xac, 0x45, 0x75, 0x26, 0x53, 0xb1, 0xc9, 0x80 \
} \
}
2015-01-22 04:35:17 +00:00
/**
* Transparency modes
*/
enum nsTransparencyMode {
eTransparencyOpaque = 0, // Fully opaque
eTransparencyTransparent, // Parts of the window may be transparent
eTransparencyGlass, // Transparent parts of the window have Vista AeroGlass
// effect applied
eTransparencyBorderlessGlass // As above, but without a border around the
// opaque areas when there would otherwise be
// one with eTransparencyGlass
// If you add to the end here, you must update the serialization code in
// WidgetMessageUtils.h
2015-01-22 04:35:17 +00:00
};
/**
* Cursor types.
*/
enum nsCursor { ///(normal cursor, usually rendered as an arrow)
eCursor_standard,
2015-01-22 04:35:17 +00:00
///(system is busy, usually rendered as a hourglass or watch)
eCursor_wait,
2015-01-22 04:35:17 +00:00
///(Selecting something, usually rendered as an IBeam)
eCursor_select,
2015-01-22 04:35:17 +00:00
///(can hyper-link, usually rendered as a human hand)
eCursor_hyperlink,
2015-01-22 04:35:17 +00:00
///(north/south/west/east edge sizing)
eCursor_n_resize,
eCursor_s_resize,
eCursor_w_resize,
eCursor_e_resize,
///(corner sizing)
eCursor_nw_resize,
eCursor_se_resize,
eCursor_ne_resize,
eCursor_sw_resize,
eCursor_crosshair,
eCursor_move,
eCursor_help,
eCursor_copy, // CSS3
eCursor_alias,
eCursor_context_menu,
eCursor_cell,
eCursor_grab,
eCursor_grabbing,
eCursor_spinning,
eCursor_zoom_in,
eCursor_zoom_out,
eCursor_not_allowed,
eCursor_col_resize,
eCursor_row_resize,
eCursor_no_drop,
eCursor_vertical_text,
eCursor_all_scroll,
eCursor_nesw_resize,
eCursor_nwse_resize,
eCursor_ns_resize,
eCursor_ew_resize,
eCursor_none,
// This one is used for array sizing, and so better be the last
// one in this list...
eCursorCount,
// ...except for this one.
eCursorInvalid = eCursorCount + 1
};
2015-01-22 04:35:17 +00:00
enum nsTopLevelWidgetZPlacement { // for PlaceBehind()
eZPlacementBottom = 0, // bottom of the window stack
eZPlacementBelow, // just below another widget
eZPlacementTop // top of the window stack
};
/**
* Before the OS goes to sleep, this topic is notified.
*/
#define NS_WIDGET_SLEEP_OBSERVER_TOPIC "sleep_notification"
/**
* After the OS wakes up, this topic is notified.
*/
#define NS_WIDGET_WAKE_OBSERVER_TOPIC "wake_notification"
/**
* Before the OS suspends the current process, this topic is notified. Some
* OS will kill processes that are suspended instead of resuming them.
* For that reason this topic may be useful to safely close down resources.
*/
#define NS_WIDGET_SUSPEND_PROCESS_OBSERVER_TOPIC "suspend_process_notification"
/**
* After the current process resumes from being suspended, this topic is
* notified.
*/
#define NS_WIDGET_RESUME_PROCESS_OBSERVER_TOPIC "resume_process_notification"
/**
* When an app(-shell) is activated by the OS, this topic is notified.
* Currently, this only happens on Mac OSX.
*/
#define NS_WIDGET_MAC_APP_ACTIVATE_OBSERVER_TOPIC "mac_app_activate"
2015-01-22 04:35:17 +00:00
namespace mozilla {
namespace widget {
/**
* Size constraints for setting the minimum and maximum size of a widget.
* Values are in device pixels.
*/
struct SizeConstraints {
SizeConstraints()
: mMaxSize(MOZ_WIDGET_MAX_SIZE, MOZ_WIDGET_MAX_SIZE),
mScale(MOZ_WIDGET_INVALID_SCALE) {}
2015-01-22 04:35:17 +00:00
SizeConstraints(mozilla::LayoutDeviceIntSize aMinSize,
mozilla::LayoutDeviceIntSize aMaxSize,
mozilla::DesktopToLayoutDeviceScale aScale)
: mMinSize(aMinSize), mMaxSize(aMaxSize), mScale(aScale) {
if (mMaxSize.width > MOZ_WIDGET_MAX_SIZE) {
mMaxSize.width = MOZ_WIDGET_MAX_SIZE;
}
if (mMaxSize.height > MOZ_WIDGET_MAX_SIZE) {
mMaxSize.height = MOZ_WIDGET_MAX_SIZE;
}
}
2015-01-22 04:35:17 +00:00
mozilla::LayoutDeviceIntSize mMinSize;
mozilla::LayoutDeviceIntSize mMaxSize;
/*
* The scale used to convert from desktop to device dimensions.
* MOZ_WIDGET_INVALID_SCALE if the value is not known.
*
* Bug 1701109 is filed to revisit adding of 'mScale' and deal
* with multi-monitor scaling issues in more complete way across
* all widget implementations.
*/
mozilla::DesktopToLayoutDeviceScale mScale;
2015-01-22 04:35:17 +00:00
};
struct AutoObserverNotifier {
AutoObserverNotifier(nsIObserver* aObserver, const char* aTopic)
: mObserver(aObserver), mTopic(aTopic) {}
void SkipNotification() { mObserver = nullptr; }
uint64_t SaveObserver() {
if (!mObserver) {
return 0;
}
uint64_t observerId = ++sObserverId;
sSavedObservers.InsertOrUpdate(observerId, mObserver);
SkipNotification();
return observerId;
}
~AutoObserverNotifier() {
if (mObserver) {
mObserver->Observe(nullptr, mTopic, nullptr);
}
}
static void NotifySavedObserver(const uint64_t& aObserverId,
const char* aTopic) {
nsCOMPtr<nsIObserver> observer = sSavedObservers.Get(aObserverId);
if (!observer) {
MOZ_ASSERT(aObserverId == 0,
"We should always find a saved observer for nonzero IDs");
return;
}
sSavedObservers.Remove(aObserverId);
observer->Observe(nullptr, aTopic, nullptr);
}
private:
nsCOMPtr<nsIObserver> mObserver;
const char* mTopic;
private:
static uint64_t sObserverId;
static nsTHashMap<uint64_t, nsCOMPtr<nsIObserver>> sSavedObservers;
};
2015-01-22 04:35:17 +00:00
} // namespace widget
} // namespace mozilla
/**
* The base class for all the widgets. It provides the interface for
* all basic and necessary functionality.
*/
class nsIWidget : public nsISupports {
2015-01-22 04:35:17 +00:00
protected:
typedef mozilla::dom::BrowserChild BrowserChild;
2015-01-22 04:35:17 +00:00
public:
typedef mozilla::layers::CompositorBridgeChild CompositorBridgeChild;
typedef mozilla::layers::AsyncDragMetrics AsyncDragMetrics;
typedef mozilla::layers::FrameMetrics FrameMetrics;
2015-01-22 04:35:17 +00:00
typedef mozilla::layers::LayerManager LayerManager;
typedef mozilla::WindowRenderer WindowRenderer;
2015-01-22 04:35:17 +00:00
typedef mozilla::layers::LayersBackend LayersBackend;
typedef mozilla::layers::LayersId LayersId;
typedef mozilla::layers::ScrollableLayerGuid ScrollableLayerGuid;
typedef mozilla::layers::ZoomConstraints ZoomConstraints;
typedef mozilla::widget::IMEEnabled IMEEnabled;
2015-01-22 04:35:17 +00:00
typedef mozilla::widget::IMEMessage IMEMessage;
typedef mozilla::widget::IMENotification IMENotification;
typedef mozilla::widget::IMENotificationRequests IMENotificationRequests;
2015-01-22 04:35:17 +00:00
typedef mozilla::widget::IMEState IMEState;
typedef mozilla::widget::InputContext InputContext;
typedef mozilla::widget::InputContextAction InputContextAction;
typedef mozilla::widget::NativeIMEContext NativeIMEContext;
2015-01-22 04:35:17 +00:00
typedef mozilla::widget::SizeConstraints SizeConstraints;
typedef mozilla::widget::TextEventDispatcher TextEventDispatcher;
typedef mozilla::widget::TextEventDispatcherListener
TextEventDispatcherListener;
typedef mozilla::LayoutDeviceIntMargin LayoutDeviceIntMargin;
typedef mozilla::LayoutDeviceIntPoint LayoutDeviceIntPoint;
typedef mozilla::LayoutDeviceIntRect LayoutDeviceIntRect;
typedef mozilla::LayoutDeviceIntRegion LayoutDeviceIntRegion;
typedef mozilla::LayoutDeviceIntSize LayoutDeviceIntSize;
typedef mozilla::ScreenIntPoint ScreenIntPoint;
typedef mozilla::ScreenIntMargin ScreenIntMargin;
typedef mozilla::ScreenIntSize ScreenIntSize;
typedef mozilla::ScreenPoint ScreenPoint;
typedef mozilla::CSSToScreenScale CSSToScreenScale;
typedef mozilla::DesktopIntRect DesktopIntRect;
typedef mozilla::DesktopPoint DesktopPoint;
typedef mozilla::DesktopRect DesktopRect;
typedef mozilla::DesktopSize DesktopSize;
typedef mozilla::CSSPoint CSSPoint;
typedef mozilla::CSSRect CSSRect;
enum class WindowButtonType {
Minimize,
Maximize,
Close,
Count,
};
2015-01-22 04:35:17 +00:00
// Used in UpdateThemeGeometries.
struct ThemeGeometry {
// The ThemeGeometryType value for the themed widget, see
// nsITheme::ThemeGeometryTypeForWidget.
nsITheme::ThemeGeometryType mType;
// The device-pixel rect within the window for the themed widget
LayoutDeviceIntRect mRect;
2015-01-22 04:35:17 +00:00
ThemeGeometry(nsITheme::ThemeGeometryType aType,
const LayoutDeviceIntRect& aRect)
: mType(aType), mRect(aRect) {}
};
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IWIDGET_IID)
nsIWidget()
2015-01-22 04:35:17 +00:00
: mLastChild(nullptr),
mPrevSibling(nullptr),
mOnDestroyCalled(false),
mWindowType(eWindowType_child),
mZIndex(0)
{
2015-01-22 04:35:17 +00:00
ClearNativeTouchSequence(nullptr);
}
2015-01-22 04:35:17 +00:00
/**
* Create and initialize a widget.
*
2015-01-22 04:35:17 +00:00
* All the arguments can be null in which case a top level window
* with size 0 is created. The event callback function has to be
* provided only if the caller wants to deal with the events this
* widget receives. The event callback is basically a preprocess
* hook called synchronously. The return value determines whether
* the event goes to the default window procedure or it is hidden
* to the os. The assumption is that if the event handler returns
* false the widget does not see the event. The widget should not
* automatically clear the window to the background color. The
* calling code must handle paint messages and clear the background
* itself.
*
2015-01-22 04:35:17 +00:00
* In practice at least one of aParent and aNativeParent will be null. If
* both are null the widget isn't parented (e.g. context menus or
* independent top level windows).
*
2015-01-22 04:35:17 +00:00
* The dimensions given in aRect are specified in the parent's
* device coordinate system.
2015-01-22 04:35:17 +00:00
* This must not be called for parentless widgets such as top-level
* windows, which use the desktop pixel coordinate system; a separate
* method is provided for these.
*
2015-01-22 04:35:17 +00:00
* @param aParent parent nsIWidget
* @param aNativeParent native parent widget
* @param aRect the widget dimension
* @param aInitData data that is used for widget initialization
*
*/
[[nodiscard]] virtual nsresult Create(
nsIWidget* aParent, nsNativeWidget aNativeParent,
const LayoutDeviceIntRect& aRect,
nsWidgetInitData* aInitData = nullptr) = 0;
/*
2015-01-22 04:35:17 +00:00
* As above, but with aRect specified in DesktopPixel units (for top-level
* widgets).
* Default implementation just converts aRect to device pixels and calls
* through to device-pixel Create, but platforms may override this if the
* mapping is not straightforward or the native platform needs to use the
2015-01-22 04:35:17 +00:00
* desktop pixel values directly.
*/
[[nodiscard]] virtual nsresult Create(nsIWidget* aParent,
nsNativeWidget aNativeParent,
const DesktopIntRect& aRect,
nsWidgetInitData* aInitData = nullptr) {
LayoutDeviceIntRect devPixRect =
2015-01-22 04:35:17 +00:00
RoundedToInt(aRect * GetDesktopToDeviceScale());
return Create(aParent, aNativeParent, devPixRect, aInitData);
}
/**
* Allocate, initialize, and return a widget that is a child of
* |this|. The returned widget (if nonnull) has gone through the
* equivalent of CreateInstance(widgetCID) + Create(...).
*
2015-01-22 04:35:17 +00:00
* |CreateChild()| lets widget backends decide whether to parent
* the new child widget to this, nonnatively parent it, or both.
* This interface exists to support the PuppetWidget backend,
* which is entirely non-native. All other params are the same as
* for |Create()|.
*
2015-01-22 04:35:17 +00:00
* |aForceUseIWidgetParent| forces |CreateChild()| to only use the
* |nsIWidget*| this, not its native widget (if it exists), when
* calling |Create()|. This is a timid hack around poorly
* understood code, and shouldn't be used in new code.
*/
2015-01-22 04:35:17 +00:00
virtual already_AddRefed<nsIWidget> CreateChild(
const LayoutDeviceIntRect& aRect, nsWidgetInitData* aInitData = nullptr,
bool aForceUseIWidgetParent = false) = 0;
/**
* Attach to a top level widget.
*
2015-01-22 04:35:17 +00:00
* In cases where a top level chrome widget is being used as a content
* container, attach a secondary listener and update the device
* context. The primary widget listener will continue to be called for
* notifications relating to the top-level window, whereas other
* notifications such as painting and events will instead be called via
* the attached listener. SetAttachedWidgetListener should be used to
* assign the attached listener.
*
2015-01-22 04:35:17 +00:00
* aUseAttachedEvents if true, events are sent to the attached listener
* instead of the normal listener.
*/
virtual void AttachViewToTopLevel(bool aUseAttachedEvents) = 0;
/**
2015-01-22 04:35:17 +00:00
* Accessor functions to get and set the attached listener. Used by
* nsView in connection with AttachViewToTopLevel above.
*/
2015-01-22 04:35:17 +00:00
virtual void SetAttachedWidgetListener(nsIWidgetListener* aListener) = 0;
virtual nsIWidgetListener* GetAttachedWidgetListener() const = 0;
virtual void SetPreviouslyAttachedWidgetListener(
2015-01-22 04:35:17 +00:00
nsIWidgetListener* aListener) = 0;
virtual nsIWidgetListener* GetPreviouslyAttachedWidgetListener() = 0;
/**
* Notifies the root widget of a non-blank paint.
*/
virtual void DidGetNonBlankPaint() {}
/**
2015-01-22 04:35:17 +00:00
* Accessor functions to get and set the listener which handles various
* actions for the widget.
*/
//@{
virtual nsIWidgetListener* GetWidgetListener() const = 0;
2015-01-22 04:35:17 +00:00
virtual void SetWidgetListener(nsIWidgetListener* alistener) = 0;
//@}
/**
* Close and destroy the internal native window.
2015-01-22 04:35:17 +00:00
* This method does not delete the widget.
*/
virtual void Destroy() = 0;
/**
2015-01-22 04:35:17 +00:00
* Destroyed() returns true if Destroy() has been called already.
* Otherwise, false.
*/
2015-01-22 04:35:17 +00:00
bool Destroyed() const { return mOnDestroyCalled; }
/**
2015-01-22 04:35:17 +00:00
* Reparent a widget
*
2015-01-22 04:35:17 +00:00
* Change the widget's parent. Null parents are allowed.
*
* @param aNewParent new parent
*/
virtual void SetParent(nsIWidget* aNewParent) = 0;
/**
* Return the parent Widget of this Widget or nullptr if this is a
2015-01-22 04:35:17 +00:00
* top level window
*
2015-01-22 04:35:17 +00:00
* @return the parent widget or nullptr if it does not have a parent
*
*/
2015-01-22 04:35:17 +00:00
virtual nsIWidget* GetParent(void) = 0;
/**
2015-01-22 04:35:17 +00:00
* Return the top level Widget of this Widget
*
2015-01-22 04:35:17 +00:00
* @return the top level widget
*/
2015-01-22 04:35:17 +00:00
virtual nsIWidget* GetTopLevelWidget() = 0;
/**
2015-01-22 04:35:17 +00:00
* Return the top (non-sheet) parent of this Widget if it's a sheet,
* or nullptr if this isn't a sheet (or some other error occurred).
* Sheets are only supported on some platforms (currently only macOS).
*
2015-01-22 04:35:17 +00:00
* @return the top (non-sheet) parent widget or nullptr
*
*/
2015-01-22 04:35:17 +00:00
virtual nsIWidget* GetSheetWindowParent(void) = 0;
/**
2015-01-22 04:35:17 +00:00
* Return the physical DPI of the screen containing the window ...
* the number of device pixels per inch.
*/
2015-01-22 04:35:17 +00:00
virtual float GetDPI() = 0;
/**
* Return the scaling factor between device pixels and the platform-
* dependent "desktop pixels" used to manage window positions on a
* potentially multi-screen, mixed-resolution desktop.
*/
virtual mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() = 0;
/**
* Return the scaling factor between device pixels and the platform-
* dependent "desktop pixels" by looking up the screen by the position
* of the widget.
*/
virtual mozilla::DesktopToLayoutDeviceScale
GetDesktopToDeviceScaleByScreen() = 0;
/**
2015-01-22 04:35:17 +00:00
* Return the default scale factor for the window. This is the
* default number of device pixels per CSS pixel to use. This should
* depend on OS/platform settings such as the Mac's "UI scale factor"
* or Windows' "font DPI". This will take into account Gecko preferences
* overriding the system setting.
*/
2015-01-22 04:35:17 +00:00
mozilla::CSSToLayoutDeviceScale GetDefaultScale();
/**
2015-01-22 04:35:17 +00:00
* Return the first child of this widget. Will return null if
* there are no children.
*/
2015-01-22 04:35:17 +00:00
nsIWidget* GetFirstChild() const { return mFirstChild; }
/**
2015-01-22 04:35:17 +00:00
* Return the last child of this widget. Will return null if
* there are no children.
*/
2015-01-22 04:35:17 +00:00
nsIWidget* GetLastChild() const { return mLastChild; }
/**
2015-01-22 04:35:17 +00:00
* Return the next sibling of this widget
*/
nsIWidget* GetNextSibling() const { return mNextSibling; }
/**
2015-01-22 04:35:17 +00:00
* Set the next sibling of this widget
*/
2015-01-22 04:35:17 +00:00
void SetNextSibling(nsIWidget* aSibling) { mNextSibling = aSibling; }
/**
2015-01-22 04:35:17 +00:00
* Return the previous sibling of this widget
*/
2015-01-22 04:35:17 +00:00
nsIWidget* GetPrevSibling() const { return mPrevSibling; }
/**
2015-01-22 04:35:17 +00:00
* Set the previous sibling of this widget
*/
2015-01-22 04:35:17 +00:00
void SetPrevSibling(nsIWidget* aSibling) { mPrevSibling = aSibling; }
/**
2015-01-22 04:35:17 +00:00
* Show or hide this widget
*
2015-01-22 04:35:17 +00:00
* @param aState true to show the Widget, false to hide it
*
*/
virtual void Show(bool aState) = 0;
/**
* Whether or not a widget must be recreated after being hidden to show
* again properly.
*/
virtual bool NeedsRecreateToReshow() { return false; }
/**
* Make the window modal.
*/
virtual void SetModal(bool aModal) = 0;
/**
* Make the non-modal window opened by modal window fake-modal, that will
* call SetFakeModal(false) on destroy on Cocoa.
*/
virtual void SetFakeModal(bool aModal) { SetModal(aModal); }
/**
* Are we app modal. Currently only implemented on Cocoa.
*/
2015-01-22 04:35:17 +00:00
virtual bool IsRunningAppModal() { return false; }
/**
2015-01-22 04:35:17 +00:00
* The maximum number of simultaneous touch contacts supported by the device.
* In the case of devices with multiple digitizers (e.g. multiple touch
* screens), the value will be the maximum of the set of maximum supported
* contacts by each individual digitizer.
*/
2015-01-22 04:35:17 +00:00
virtual uint32_t GetMaxTouchPoints() const = 0;
/**
2015-01-22 04:35:17 +00:00
* Returns whether the window is visible
*
*/
2015-01-22 04:35:17 +00:00
virtual bool IsVisible() const = 0;
/**
2015-01-22 04:35:17 +00:00
* Perform platform-dependent sanity check on a potential window position.
* This is guaranteed to work only for top-level windows.
*
2015-01-22 04:35:17 +00:00
* @param aAllowSlop: if true, allow the window to slop offscreen;
* the window should be partially visible. if false,
* force the entire window onscreen (or at least
* the upper-left corner, if it's too large).
* @param aX in: an x position expressed in screen coordinates.
* out: the x position constrained to fit on the screen(s).
* @param aY in: an y position expressed in screen coordinates.
* out: the y position constrained to fit on the screen(s).
*
**/
virtual void ConstrainPosition(bool aAllowSlop, int32_t* aX, int32_t* aY) = 0;
/**
* NOTE:
*
2015-01-22 04:35:17 +00:00
* For a top-level window widget, the "parent's coordinate system" is the
* "global" display pixel coordinate space, *not* device pixels (which
* may be inconsistent between multiple screens, at least in the Mac OS
* case with mixed hi-dpi and lo-dpi displays). This applies to all the
* following Move and Resize widget APIs.
*
2015-01-22 04:35:17 +00:00
* The display-/device-pixel distinction becomes important for (at least)
* macOS with Hi-DPI (retina) displays, and Windows when the UI scale factor
* is set to other than 100%.
*
2015-01-22 04:35:17 +00:00
* The Move and Resize methods take floating-point parameters, rather than
* integer ones. This is important when manipulating top-level widgets,
* where the coordinate system may not be an integral multiple of the
* device-pixel space.
**/
/**
2015-01-22 04:35:17 +00:00
* Move this widget.
*
2015-01-22 04:35:17 +00:00
* Coordinates refer to the top-left of the widget. For toplevel windows
* with decorations, this is the top-left of the titlebar and frame .
*
2015-01-22 04:35:17 +00:00
* @param aX the new x position expressed in the parent's coordinate system
* @param aY the new y position expressed in the parent's coordinate system
*
**/
virtual void Move(double aX, double aY) = 0;
/**
2015-01-22 04:35:17 +00:00
* Reposition this widget so that the client area has the given offset.
*
* @param aOffset the new offset of the client area expressed as an
2015-01-22 04:35:17 +00:00
* offset from the origin of the client area of the parent
* widget (for root widgets and popup widgets it is in
* screen coordinates)
**/
virtual void MoveClient(const DesktopPoint& aOffset) = 0;
/**
2015-01-22 04:35:17 +00:00
* Resize this widget. Any size constraints set for the window by a
* previous call to SetSizeConstraints will be applied.
*
2015-01-22 04:35:17 +00:00
* @param aWidth the new width expressed in the parent's coordinate system
* @param aHeight the new height expressed in the parent's coordinate
* system
2015-01-22 04:35:17 +00:00
* @param aRepaint whether the widget should be repainted
*/
virtual void Resize(double aWidth, double aHeight, bool aRepaint) = 0;
/**
* Lock the aspect ratio of a Window
*
* @param aShouldLock bool
*
*/
virtual void LockAspectRatio(bool aShouldLock){};
/**
2015-01-22 04:35:17 +00:00
* Move or resize this widget. Any size constraints set for the window by
* a previous call to SetSizeConstraints will be applied.
*
2015-01-22 04:35:17 +00:00
* @param aX the new x position expressed in the parent's coordinate
* system
2015-01-22 04:35:17 +00:00
* @param aY the new y position expressed in the parent's coordinate
* system
2015-01-22 04:35:17 +00:00
* @param aWidth the new width expressed in the parent's coordinate system
* @param aHeight the new height expressed in the parent's coordinate
* system
2015-01-22 04:35:17 +00:00
* @param aRepaint whether the widget should be repainted if the size
* changes
*
*/
virtual void Resize(double aX, double aY, double aWidth, double aHeight,
bool aRepaint) = 0;
virtual mozilla::Maybe<bool> IsResizingNativeWidget() {
return mozilla::Nothing();
2015-01-22 04:35:17 +00:00
}
2015-01-22 04:35:17 +00:00
/**
* Resize the widget so that the inner client area has the given size.
*
* @param aSize the new size of the client area.
2015-01-22 04:35:17 +00:00
* @param aRepaint whether the widget should be repainted
*/
virtual void ResizeClient(const DesktopSize& aSize, bool aRepaint) = 0;
/**
2015-01-22 04:35:17 +00:00
* Resize and reposition the widget so tht inner client area has the given
* offset and size.
*
* @param aRect the new offset and size of the client area. The offset is
* expressed as an offset from the origin of the client area
* of the parent widget (for root widgets and popup widgets it
* is in screen coordinates).
2015-01-22 04:35:17 +00:00
* @param aRepaint whether the widget should be repainted
*/
virtual void ResizeClient(const DesktopRect& aRect, bool aRepaint) = 0;
/**
2015-01-22 04:35:17 +00:00
* Sets the widget's z-index.
*/
2015-01-22 04:35:17 +00:00
virtual void SetZIndex(int32_t aZIndex) = 0;
/**
* Gets the widget's z-index.
*/
2015-01-22 04:35:17 +00:00
int32_t GetZIndex() { return mZIndex; }
/**
2015-01-22 04:35:17 +00:00
* Position this widget just behind the given widget. (Used to
* control z-order for top-level widgets. Get/SetZIndex by contrast
* control z-order for child widgets of other widgets.)
* @param aPlacement top, bottom, or below a widget
* (if top or bottom, param aWidget is ignored)
* @param aWidget widget to place this widget behind
* (only if aPlacement is eZPlacementBelow).
* null is equivalent to aPlacement of eZPlacementTop
* @param aActivate true to activate the widget after placing it
*/
virtual void PlaceBehind(nsTopLevelWidgetZPlacement aPlacement,
nsIWidget* aWidget, bool aActivate) = 0;
/**
2015-01-22 04:35:17 +00:00
* Minimize, maximize or normalize the window size.
* Takes a value from nsSizeMode (see nsIWidgetListener.h)
*/
virtual void SetSizeMode(nsSizeMode aMode) = 0;
virtual void GetWorkspaceID(nsAString& workspaceID) = 0;
virtual void MoveToWorkspace(const nsAString& workspaceID) = 0;
/**
* Suppress animations that are applied to a window by OS.
*/
virtual void SuppressAnimation(bool aSuppress) {}
/**
2015-01-22 04:35:17 +00:00
* Return size mode (minimized, maximized, normalized).
* Returns a value from nsSizeMode (see nsIWidgetListener.h)
*/
virtual nsSizeMode SizeMode() = 0;
/**
* Ask whether the window is tiled.
*/
virtual bool IsTiled() const = 0;
/**
* Ask wether the widget is fully occluded
*/
virtual bool IsFullyOccluded() const = 0;
/**
2015-01-22 04:35:17 +00:00
* Enable or disable this Widget
*
2015-01-22 04:35:17 +00:00
* @param aState true to enable the Widget, false to disable it.
*/
virtual void Enable(bool aState) = 0;
/**
2015-01-22 04:35:17 +00:00
* Ask whether the widget is enabled
*/
2015-01-22 04:35:17 +00:00
virtual bool IsEnabled() const = 0;
/*
* Whether we should request activation of this widget's toplevel window.
*/
enum class Raise {
No,
Yes,
};
/**
2015-01-22 04:35:17 +00:00
* Request activation of this window or give focus to this widget.
*/
virtual void SetFocus(Raise, mozilla::dom::CallerType aCallerType) = 0;
/**
2015-01-22 04:35:17 +00:00
* Get this widget's outside dimensions relative to its parent widget. For
* popup widgets the returned rect is in screen coordinates and not
* relative to its parent widget.
*
* @return the x, y, width and height of this widget.
*/
virtual LayoutDeviceIntRect GetBounds() = 0;
/**
* Get this widget's outside dimensions in device coordinates. This
2015-01-22 04:35:17 +00:00
* includes any title bar on the window.
*
* @return the x, y, width and height of this widget.
*/
virtual LayoutDeviceIntRect GetScreenBounds() = 0;
/**
2015-01-22 04:35:17 +00:00
* Similar to GetScreenBounds except that this function will always
* get the size when the widget is in the nsSizeMode_Normal size mode
* even if the current size mode is not nsSizeMode_Normal.
* This method will fail if the size mode is not nsSizeMode_Normal and
* the platform doesn't have the ability.
* This method will always succeed if the current size mode is
* nsSizeMode_Normal.
*
2015-01-22 04:35:17 +00:00
* @param aRect On return it holds the x, y, width and height of
* this widget.
*/
[[nodiscard]] virtual nsresult GetRestoredBounds(
LayoutDeviceIntRect& aRect) = 0;
/**
2015-01-22 04:35:17 +00:00
* Get this widget's client area bounds, if the window has a 3D border
* appearance this returns the area inside the border. The position is the
* position of the client area relative to the client area of the parent
* widget (for root widgets and popup widgets it is in screen coordinates).
*
* @return the x, y, width and height of the client area of this widget.
*/
2015-01-22 04:35:17 +00:00
virtual LayoutDeviceIntRect GetClientBounds() = 0;
/**
2015-01-22 04:35:17 +00:00
* Sets the non-client area dimensions of the window. Pass -1 to restore
* the system default frame size for that border. Pass zero to remove
* a border, or pass a specific value adjust a border. Units are in
* pixels. (DPI dependent)
*
2015-01-22 04:35:17 +00:00
* Platform notes:
* Windows: shrinking top non-client height will remove application
* icon and window title text. Glass desktops will refuse to set
* dimensions between zero and size < system default.
*/
virtual nsresult SetNonClientMargins(LayoutDeviceIntMargin& aMargins) = 0;
/**
2015-01-22 04:35:17 +00:00
* Get the client offset from the window origin.
*
2015-01-22 04:35:17 +00:00
* @return the x and y of the offset.
*/
virtual LayoutDeviceIntPoint GetClientOffset() = 0;
/**
* Equivalent to GetClientBounds but only returns the size.
*/
virtual LayoutDeviceIntSize GetClientSize() {
2015-01-22 04:35:17 +00:00
// Depending on the backend, overloading this method may be useful if
// requesting the client offset is expensive.
return GetClientBounds().Size();
}
2015-01-22 04:35:17 +00:00
/**
* Set the background color for this widget
*
2015-01-22 04:35:17 +00:00
* @param aColor the new background color
*
*/
2015-01-22 04:35:17 +00:00
virtual void SetBackgroundColor(const nscolor& aColor) {}
/**
2015-01-22 04:35:17 +00:00
* If a cursor type is currently cached locally for this widget, clear the
* cached cursor to force an update on the next SetCursor call.
*/
2015-01-22 04:35:17 +00:00
virtual void ClearCachedCursor() = 0;
struct Cursor {
// The system cursor chosen by the page. This is used if there's no custom
// cursor, or if we fail to use the custom cursor in some way (if the image
// fails to load, for example).
nsCursor mDefaultCursor = eCursor_standard;
// May be null, to represent no custom cursor image.
nsCOMPtr<imgIContainer> mContainer;
uint32_t mHotspotX = 0;
uint32_t mHotspotY = 0;
mozilla::ImageResolution mResolution;
bool IsCustom() const { return !!mContainer; }
bool operator==(const Cursor& aOther) const {
return mDefaultCursor == aOther.mDefaultCursor &&
mContainer.get() == aOther.mContainer.get() &&
mHotspotX == aOther.mHotspotX && mHotspotY == aOther.mHotspotY &&
mResolution == aOther.mResolution;
}
bool operator!=(const Cursor& aOther) const { return !(*this == aOther); }
};
/**
* Sets the cursor for this widget.
*/
virtual void SetCursor(const Cursor&) = 0;
static nsIntSize CustomCursorSize(const Cursor&);
/**
2015-01-22 04:35:17 +00:00
* Get the window type of this widget.
*/
2015-01-22 04:35:17 +00:00
nsWindowType WindowType() { return mWindowType; }
2015-01-22 04:35:17 +00:00
/**
* Set the transparency mode of the top-level window containing this widget.
* So, e.g., if you call this on the widget for an IFRAME, the top level
* browser window containing the IFRAME actually gets set. Be careful.
*
* This can fail if the platform doesn't support
* transparency/glass. By default widgets are not
* transparent. This will also fail if the toplevel window is not
* a Mozilla window, e.g., if the widget is in an embedded
* context.
*
2015-01-22 04:35:17 +00:00
* After transparency/glass has been enabled, the initial alpha channel
* value for all pixels is 1, i.e., opaque.
* If the window is resized then the alpha channel values for
* all pixels are reset to 1.
* Pixel RGB color values are already premultiplied with alpha channel values.
*/
2015-01-22 04:35:17 +00:00
virtual void SetTransparencyMode(nsTransparencyMode aMode) = 0;
/**
2015-01-22 04:35:17 +00:00
* Get the transparency mode of the top-level window that contains this
* widget.
*/
2015-01-22 04:35:17 +00:00
virtual nsTransparencyMode GetTransparencyMode() = 0;
2015-01-22 04:35:17 +00:00
/**
* Set the shadow style of the window.
*
2015-01-22 04:35:17 +00:00
* Ignored on child widgets and on non-Mac platforms.
*/
virtual void SetWindowShadowStyle(mozilla::StyleWindowShadow aStyle) = 0;
2015-01-22 04:35:17 +00:00
/**
* Set the opacity of the window.
* Values need to be between 0.0f (invisible) and 1.0f (fully opaque).
*
* Ignored on child widgets and on non-Mac platforms.
*/
virtual void SetWindowOpacity(float aOpacity) {}
2015-01-22 04:35:17 +00:00
/**
* Set the transform of the window. Values are in device pixels,
* the origin is the top left corner of the window.
*
2015-01-22 04:35:17 +00:00
* Ignored on child widgets and on non-Mac platforms.
*/
2015-01-22 04:35:17 +00:00
virtual void SetWindowTransform(const mozilla::gfx::Matrix& aTransform) {}
/**
* Set the preferred color-scheme for the widget.
* Ignored on non-Mac platforms.
*/
virtual void SetColorScheme(const mozilla::Maybe<mozilla::ColorScheme>&) {}
/**
* Set whether the window should ignore mouse events or not.
*
* This is only used on popup windows.
*/
virtual void SetWindowMouseTransparent(bool aIsTransparent) {}
/*
* On macOS, this method shows or hides the pill button in the titlebar
2015-01-22 04:35:17 +00:00
* that's used to collapse the toolbar.
*
* Ignored on child widgets and on non-Mac platforms.
*/
virtual void SetShowsToolbarButton(bool aShow) = 0;
/*
* On macOS, this method determines whether we tell cocoa that the window
* supports native full screen. If we do so, and another window is in
* native full screen, this window will also appear in native full screen.
*
* We generally only want to do this for primary application windows.
*
* Ignored on child widgets and on non-Mac platforms.
*/
virtual void SetSupportsNativeFullscreen(bool aSupportsNativeFullscreen) = 0;
enum WindowAnimationType {
eGenericWindowAnimation,
eDocumentWindowAnimation
};
2015-01-22 04:35:17 +00:00
/**
* Sets the kind of top-level window animation this widget should have. On
* macOS, this causes a particular kind of animation to be shown when the
2015-01-22 04:35:17 +00:00
* window is first made visible.
*
2015-01-22 04:35:17 +00:00
* Ignored on child widgets and on non-Mac platforms.
*/
2015-01-22 04:35:17 +00:00
virtual void SetWindowAnimationType(WindowAnimationType aType) = 0;
/**
2015-01-22 04:35:17 +00:00
* Specifies whether the window title should be drawn even if the window
* contents extend into the titlebar. Ignored on windows that don't draw
* in the titlebar. Only implemented on macOS.
2015-01-22 04:35:17 +00:00
*/
virtual void SetDrawsTitle(bool aDrawTitle) {}
2015-01-22 04:35:17 +00:00
/**
* Hide window chrome (borders, buttons) for this widget.
*
2015-01-22 04:35:17 +00:00
*/
virtual void HideWindowChrome(bool aShouldHide) = 0;
enum FullscreenTransitionStage {
2015-01-22 04:35:17 +00:00
eBeforeFullscreenToggle,
eAfterFullscreenToggle
};
/**
* Prepares for fullscreen transition and returns whether the widget
* supports fullscreen transition. If this method returns false,
* PerformFullscreenTransition() must never be called. Otherwise,
* caller should call that method twice with "before" and "after"
* stages respectively in order. In the latter case, this method may
* return some data via aData pointer. Caller must pass that data to
* PerformFullscreenTransition() if any, and caller is responsible
* for releasing that data.
*/
virtual bool PrepareForFullscreenTransition(nsISupports** aData) = 0;
2015-01-22 04:35:17 +00:00
/**
* Performs fullscreen transition. This method returns immediately,
* and will post aCallback to the main thread when the transition
* finishes.
*/
virtual void PerformFullscreenTransition(FullscreenTransitionStage aStage,
uint16_t aDuration,
2015-01-22 04:35:17 +00:00
nsISupports* aData,
nsIRunnable* aCallback) = 0;
2015-01-22 04:35:17 +00:00
/**
* Perform any actions needed after the fullscreen transition has ended.
*/
virtual void CleanupFullscreenTransition() = 0;
2015-01-22 04:35:17 +00:00
/**
* Return the screen the widget is in, or null if we don't know.
*/
virtual already_AddRefed<nsIScreen> GetWidgetScreen() = 0;
2015-01-22 04:35:17 +00:00
/**
* Put the toplevel window into or out of fullscreen mode.
* If aTargetScreen is given, attempt to go fullscreen on that screen,
* if possible. (If not, it behaves as if aTargetScreen is null.)
* If !aFullScreen, aTargetScreen is ignored.
* aTargetScreen support is currently only implemented on Windows.
*
* @return NS_OK if the widget is setup properly for fullscreen and
* FullscreenChanged callback has been or will be called. If other
* value is returned, the caller should continue the change itself.
2015-01-22 04:35:17 +00:00
*/
virtual nsresult MakeFullScreen(bool aFullScreen,
2015-01-22 04:35:17 +00:00
nsIScreen* aTargetScreen = nullptr) = 0;
/**
2015-01-22 04:35:17 +00:00
* Same as MakeFullScreen, except that, on systems which natively
* support fullscreen transition, calling this method explicitly
* requests that behavior.
* It is currently only supported on macOS 10.7+.
2015-01-22 04:35:17 +00:00
*/
virtual nsresult MakeFullScreenWithNativeTransition(
bool aFullScreen, nsIScreen* aTargetScreen = nullptr) {
return MakeFullScreen(aFullScreen, aTargetScreen);
}
2015-01-22 04:35:17 +00:00
/**
* Invalidate a specified rect for a widget so that it will be repainted
* later.
*/
virtual void Invalidate(const LayoutDeviceIntRect& aRect) = 0;
2015-01-22 04:35:17 +00:00
enum LayerManagerPersistence {
LAYER_MANAGER_CURRENT = 0,
LAYER_MANAGER_PERSISTENT
};
/**
* Return the widget's LayerManager. The layer tree for that
* LayerManager is what gets rendered to the widget.
*/
virtual WindowRenderer* GetWindowRenderer() = 0;
/**
2015-01-22 04:35:17 +00:00
* Called before each layer manager transaction to allow any preparation
* for DrawWindowUnderlay/Overlay that needs to be on the main thread.
*
2015-01-22 04:35:17 +00:00
* Always called on the main thread.
*/
2015-01-22 04:35:17 +00:00
virtual void PrepareWindowEffects() = 0;
/**
2015-01-22 04:35:17 +00:00
* Called on the main thread at the end of WebRender display list building.
*/
virtual void AddWindowOverlayWebRenderCommands(
mozilla::layers::WebRenderBridgeChild* aWrBridge,
mozilla::wr::DisplayListBuilder& aBuilder,
2015-01-22 04:35:17 +00:00
mozilla::wr::IpcResourceUpdateQueue& aResources) {}
/**
2015-01-22 04:35:17 +00:00
* Called when Gecko knows which themed widgets exist in this window.
* The passed array contains an entry for every themed widget of the right
* type (currently only StyleAppearance::Toolbar) within the window, except
* for themed widgets which are transformed or have effects applied to them
* (e.g. CSS opacity or filters).
* This could sometimes be called during display list construction
* outside of painting.
* If called during painting, it will be called before we actually
* paint anything.
*/
virtual void UpdateThemeGeometries(
const nsTArray<ThemeGeometry>& aThemeGeometries) = 0;
/**
2015-01-22 04:35:17 +00:00
* Informs the widget about the region of the window that is opaque.
*
* @param aOpaqueRegion the region of the window that is opaque.
*/
virtual void UpdateOpaqueRegion(const LayoutDeviceIntRegion& aOpaqueRegion) {}
2015-01-22 04:35:17 +00:00
/**
* Informs the widget about the region of the window that is draggable.
*/
virtual void UpdateWindowDraggingRegion(
const LayoutDeviceIntRegion& aRegion) {}
/**
* Tells the widget whether the given input block results in a swipe.
* Should be called in response to a WidgetWheelEvent that has
* mFlags.mCanTriggerSwipe set on it.
*/
virtual void ReportSwipeStarted(uint64_t aInputBlockId, bool aStartSwipe) {}
/**
2015-01-22 04:35:17 +00:00
* Internal methods
*/
//@{
2015-01-22 04:35:17 +00:00
virtual void AddChild(nsIWidget* aChild) = 0;
virtual void RemoveChild(nsIWidget* aChild) = 0;
virtual void* GetNativeData(uint32_t aDataType) = 0;
virtual void SetNativeData(uint32_t aDataType, uintptr_t aVal) = 0;
2015-01-22 04:35:17 +00:00
virtual void FreeNativeData(void* data, uint32_t aDataType) = 0; //~~~
//@}
/**
2015-01-22 04:35:17 +00:00
* Set the widget's title.
* Must be called after Create.
*
2015-01-22 04:35:17 +00:00
* @param aTitle string displayed as the title of the widget
*/
virtual nsresult SetTitle(const nsAString& aTitle) = 0;
/**
2015-01-22 04:35:17 +00:00
* Set the widget's icon.
* Must be called after Create.
*
* @param aIconSpec string specifying the icon to use; convention is to
* pass a resource: URL from which a platform-dependent
* resource file name will be constructed
*/
virtual void SetIcon(const nsAString& aIconSpec) = 0;
/**
2015-01-22 04:35:17 +00:00
* Return this widget's origin in screen coordinates.
*
2015-01-22 04:35:17 +00:00
* @return screen coordinates stored in the x,y members
*/
virtual LayoutDeviceIntPoint WidgetToScreenOffset() = 0;
/**
* The same as WidgetToScreenOffset(), except in the case of
* PuppetWidget where this method omits the chrome offset.
*/
virtual LayoutDeviceIntPoint TopLevelWidgetToScreenOffset() {
return WidgetToScreenOffset();
}
/**
* For a PuppetWidget, returns the transform from the coordinate
* space of the PuppetWidget to the coordinate space of the
* top-level native widget.
*
* Identity transform in other cases.
*/
virtual mozilla::LayoutDeviceToLayoutDeviceMatrix4x4
WidgetToTopLevelWidgetTransform() {
return mozilla::LayoutDeviceToLayoutDeviceMatrix4x4();
}
/**
2015-01-22 04:35:17 +00:00
* Given the specified client size, return the corresponding window size,
* which includes the area for the borders and titlebar. This method
* should work even when the window is not yet visible.
*/
2015-01-22 04:35:17 +00:00
virtual LayoutDeviceIntSize ClientToWindowSize(
const LayoutDeviceIntSize& aClientSize) = 0;
/**
2015-01-22 04:35:17 +00:00
* Dispatches an event to the widget
*/
virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* event,
nsEventStatus& aStatus) = 0;
/**
* Dispatches an event to APZ only.
* No-op in the child process.
*/
virtual void DispatchEventToAPZOnly(mozilla::WidgetInputEvent* aEvent) = 0;
/*
* Dispatch a gecko event for this widget.
* Returns true if it's consumed. Otherwise, false.
*/
virtual bool DispatchWindowEvent(mozilla::WidgetGUIEvent& event) = 0;
// A structure that groups the statuses from APZ dispatch and content
// dispatch.
struct ContentAndAPZEventStatus {
// Either of these may not be set if the event was not dispatched
// to APZ or to content.
nsEventStatus mApzStatus = nsEventStatus_eIgnore;
nsEventStatus mContentStatus = nsEventStatus_eIgnore;
};
/**
* Dispatches an event that must be handled by APZ first, when APZ is
* enabled. If invoked in the child process, it is forwarded to the
* parent process synchronously.
*/
virtual ContentAndAPZEventStatus DispatchInputEvent(
mozilla::WidgetInputEvent* aEvent) = 0;
/**
* Confirm an APZ-aware event target. This should be used when APZ will
2015-01-22 04:35:17 +00:00
* not need a layers update to process the event.
*/
virtual void SetConfirmedTargetAPZC(
uint64_t aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets) const = 0;
/**
2015-01-22 04:35:17 +00:00
* Returns true if APZ is in use, false otherwise.
*/
virtual bool AsyncPanZoomEnabled() const = 0;
/**
*/
virtual void SwipeFinished() = 0;
/**
* Enables the dropping of files to a widget.
*/
virtual void EnableDragDrop(bool aEnable) = 0;
virtual nsresult AsyncEnableDragDrop(bool aEnable) = 0;
/**
2015-01-22 04:35:17 +00:00
* Enables/Disables system mouse capture.
* @param aCapture true enables mouse capture, false disables mouse capture
*
*/
virtual void CaptureMouse(bool aCapture) = 0;
/**
2015-01-22 04:35:17 +00:00
* Classify the window for the window manager. Mostly for X11.
*/
virtual void SetWindowClass(const nsAString& xulWinType) = 0;
/**
2015-01-22 04:35:17 +00:00
* Enables/Disables system capture of any and all events that would cause a
* popup to be rolled up. aListener should be set to a non-null value for
* any popups that are not managed by the popup manager.
* @param aDoCapture true enables capture, false disables capture
*
*/
virtual void CaptureRollupEvents(nsIRollupListener* aListener,
bool aDoCapture) = 0;
/**
2015-01-22 04:35:17 +00:00
* Bring this window to the user's attention. This is intended to be a more
* gentle notification than popping the window to the top or putting up an
* alert. See, for example, Win32 FlashWindow or the NotificationManager on
* the Mac. The notification should be suppressed if the window is already
* in the foreground and should be dismissed when the user brings this window
* to the foreground.
* @param aCycleCount Maximum number of times to animate the window per system
* conventions. If set to -1, cycles indefinitely until
2015-01-22 04:35:17 +00:00
* window is brought into the foreground.
*/
[[nodiscard]] virtual nsresult GetAttention(int32_t aCycleCount) = 0;
/**
2015-01-22 04:35:17 +00:00
* Ask whether there user input events pending. All input events are
* included, including those not targeted at this nsIwidget instance.
*/
2015-01-22 04:35:17 +00:00
virtual bool HasPendingInputEvent() = 0;
/**
2015-01-22 04:35:17 +00:00
* If set to true, the window will draw its contents into the titlebar
* instead of below it.
*
2015-01-22 04:35:17 +00:00
* Ignored on any platform that does not support it. Ignored by widgets that
* do not represent windows.
* May result in a resize event, so should only be called from places where
* reflow and painting is allowed.
*
2015-01-22 04:35:17 +00:00
* @param aState Whether drawing into the titlebar should be activated.
*/
2015-01-22 04:35:17 +00:00
virtual void SetDrawsInTitlebar(bool aState) = 0;
/*
2015-01-22 04:35:17 +00:00
* Determine whether the widget shows a resize widget. If it does,
* aResizerRect returns the resizer's rect.
*
2015-01-22 04:35:17 +00:00
* Returns false on any platform that does not support it.
*
2015-01-22 04:35:17 +00:00
* @param aResizerRect The resizer's rect in device pixels.
* @return Whether a resize widget is shown.
*/
virtual bool ShowsResizeIndicator(LayoutDeviceIntRect* aResizerRect) = 0;
/**
2015-01-22 04:35:17 +00:00
* Begin a window resizing drag, based on the event passed in.
*/
[[nodiscard]] virtual nsresult BeginResizeDrag(
mozilla::WidgetGUIEvent* aEvent, int32_t aHorizontal,
int32_t aVertical) = 0;
// TODO: Make this an enum class with MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS or
// EnumSet class.
enum Modifiers : uint32_t {
NO_MODIFIERS = 0x00000000,
Bug 900750 - part 2: Make ModifierKeyState and VirtualKey treat AltGraph as new modifier and won't set Control and Alt state while AltGraph is active r=m_kato,smaug By the proposal from Google, <https://github.com/w3c/uievents/issues/147>, Chromium treat AltRight key as "AltGraph" modifier if the keyboard layout has AltGr key. When AltRight key is pressed with a keyboard layout which has AltGr key, modifiers should as following: 1. "keydown" for ControlLeft: ctrlKey: true, altKey: false, getModifierState("AltGraph"): false 2. "keydown" for AltRight: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 3. Some "keydown", "keypress" and "keyup" events: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 4. "keyup" for ControlLeft: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 5. "keyup" for AltRight: ctrlKey: false, altKey: false, getModifierState("AltGraph"): false So, only when the preceding "keydown" event for ControlLeft, ctrlKey should be set to true as usual. However, after AltRight key is pressed actually, we should treat "AltGraph" modifier is true and both ctrlKey and altKey should be set to false for web apps can handle text input normally. So, MODIFIER_ALTGRAPH and MODIFIER_CONTROL/MODIFIER_ALT should not be set at the same time. This patch makes ModifierKeyState have only MODIFIER_ALTGRAPH or MODIFIER_CONTROL/MODIFIER_ALT. Additionally, this patch makes VirtualKey::ShiftState treat "AltGraph" as a modifier. So, now, VirtualKey needs to convert ShiftState to index value when it accesses its mShiftStates array. Therefore, this patch adds VirtualKey::ToIndex() and make each VirtualKey method use it before accessing mShiftStates. Note that this patch also fixes bug of WinUtils::SetupKeyModifiersSequence(). The constructor of KeyPair takes 2 keycode values, but the second virtual keycode can have scancode to distinguish if the key is left or right. However, WinUtils::SetupKeyModifiersSequence() never sets scancode to KeyPair. Therefore, it fails to dispatch AltRight key event. MozReview-Commit-ID: 7ealxJH9KlZ --HG-- extra : rebase_source : 761bc4416222def020a0731d6ae7940ef074ebe0
2018-05-30 08:27:31 +00:00
CAPS_LOCK = 0x00000001, // when CapsLock is active
NUM_LOCK = 0x00000002, // when NumLock is active
SHIFT_L = 0x00000100,
SHIFT_R = 0x00000200,
CTRL_L = 0x00000400,
CTRL_R = 0x00000800,
ALT_L = 0x00001000, // includes Option
ALT_R = 0x00002000,
COMMAND_L = 0x00004000,
COMMAND_R = 0x00008000,
HELP = 0x00010000,
ALTGRAPH = 0x00020000, // AltGr key on Windows. This emulates
// AltRight key behavior of keyboard
2015-01-22 04:35:17 +00:00
// layouts which maps AltGr to AltRight
// key.
Bug 900750 - part 2: Make ModifierKeyState and VirtualKey treat AltGraph as new modifier and won't set Control and Alt state while AltGraph is active r=m_kato,smaug By the proposal from Google, <https://github.com/w3c/uievents/issues/147>, Chromium treat AltRight key as "AltGraph" modifier if the keyboard layout has AltGr key. When AltRight key is pressed with a keyboard layout which has AltGr key, modifiers should as following: 1. "keydown" for ControlLeft: ctrlKey: true, altKey: false, getModifierState("AltGraph"): false 2. "keydown" for AltRight: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 3. Some "keydown", "keypress" and "keyup" events: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 4. "keyup" for ControlLeft: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 5. "keyup" for AltRight: ctrlKey: false, altKey: false, getModifierState("AltGraph"): false So, only when the preceding "keydown" event for ControlLeft, ctrlKey should be set to true as usual. However, after AltRight key is pressed actually, we should treat "AltGraph" modifier is true and both ctrlKey and altKey should be set to false for web apps can handle text input normally. So, MODIFIER_ALTGRAPH and MODIFIER_CONTROL/MODIFIER_ALT should not be set at the same time. This patch makes ModifierKeyState have only MODIFIER_ALTGRAPH or MODIFIER_CONTROL/MODIFIER_ALT. Additionally, this patch makes VirtualKey::ShiftState treat "AltGraph" as a modifier. So, now, VirtualKey needs to convert ShiftState to index value when it accesses its mShiftStates array. Therefore, this patch adds VirtualKey::ToIndex() and make each VirtualKey method use it before accessing mShiftStates. Note that this patch also fixes bug of WinUtils::SetupKeyModifiersSequence(). The constructor of KeyPair takes 2 keycode values, but the second virtual keycode can have scancode to distinguish if the key is left or right. However, WinUtils::SetupKeyModifiersSequence() never sets scancode to KeyPair. Therefore, it fails to dispatch AltRight key event. MozReview-Commit-ID: 7ealxJH9KlZ --HG-- extra : rebase_source : 761bc4416222def020a0731d6ae7940ef074ebe0
2018-05-30 08:27:31 +00:00
FUNCTION = 0x00100000,
NUMERIC_KEY_PAD = 0x01000000 // when the key is coming from the keypad
};
/**
2015-01-22 04:35:17 +00:00
* Utility method intended for testing. Dispatches native key events
* to this widget to simulate the press and release of a key.
* @param aNativeKeyboardLayout a *platform-specific* constant.
* On Mac, this is the resource ID for a 'uchr' or 'kchr' resource.
* On Windows, it is converted to a hex string and passed to
* LoadKeyboardLayout, see
* http://msdn.microsoft.com/en-us/library/ms646305(VS.85).aspx
2015-01-22 04:35:17 +00:00
* @param aNativeKeyCode a *platform-specific* keycode.
* On Windows, this is the virtual key code.
* @param aModifiers some combination of the above 'Modifiers' flags;
* not all flags will apply to all platforms. Mac ignores the _R
* modifiers. Windows ignores COMMAND, NUMERIC_KEY_PAD, HELP and
* FUNCTION.
* @param aCharacters characters that the OS would decide to generate
* from the event. On Windows, this is the charCode passed by
* WM_CHAR.
* @param aUnmodifiedCharacters characters that the OS would decide
* to generate from the event if modifier keys (other than shift)
* were assumed inactive. Needed on Mac, ignored on Windows.
* @param aObserver the observer that will get notified once the events
* have been dispatched.
2015-01-22 04:35:17 +00:00
* @return NS_ERROR_NOT_AVAILABLE to indicate that the keyboard
* layout is not supported and the event was not fired
*/
2015-01-22 04:35:17 +00:00
virtual nsresult SynthesizeNativeKeyEvent(
int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode,
uint32_t aModifierFlags, const nsAString& aCharacters,
const nsAString& aUnmodifiedCharacters, nsIObserver* aObserver) = 0;
/**
2015-01-22 04:35:17 +00:00
* Utility method intended for testing. Dispatches native mouse events
* may even move the mouse cursor. On Mac the events are guaranteed to
2015-01-22 04:35:17 +00:00
* be sent to the window containing this widget, but on Windows they'll go
* to whatever's topmost on the screen at that position, so for
* cross-platform testing ensure that your window is at the top of the
* z-order.
* @param aPoint screen location of the mouse, in device
2015-01-22 04:35:17 +00:00
* pixels, with origin at the top left
* @param aNativeMessage abstract native message.
* @param aButton Mouse button defined by DOM UI Events.
* @param aModifierFlags Some values of nsIWidget::Modifiers.
* FYI: On Windows, Android and Headless widget on all
* platroms, this hasn't been handled yet.
* @param aObserver the observer that will get notified once the events
* have been dispatched.
*/
enum class NativeMouseMessage : uint32_t {
ButtonDown, // button down
ButtonUp, // button up
Move, // mouse cursor move
EnterWindow, // mouse cursor comes into a window
LeaveWindow, // mouse cursor leaves from a window
};
virtual nsresult SynthesizeNativeMouseEvent(
LayoutDeviceIntPoint aPoint, NativeMouseMessage aNativeMessage,
mozilla::MouseButton aButton, nsIWidget::Modifiers aModifierFlags,
nsIObserver* aObserver) = 0;
2015-01-22 04:35:17 +00:00
/**
* A shortcut to SynthesizeNativeMouseEvent, abstracting away the native
* message. aPoint is location in device pixels to which the mouse pointer
2015-01-22 04:35:17 +00:00
* moves to.
* @param aObserver the observer that will get notified once the events
* have been dispatched.
*/
virtual nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
nsIObserver* aObserver) = 0;
/**
* Utility method intended for testing. Dispatching native mouse scroll
* events may move the mouse cursor.
*
* @param aPoint Mouse cursor position in screen coordinates.
2015-01-22 04:35:17 +00:00
* In device pixels, the origin at the top left of
* the primary display.
* @param aNativeMessage Platform native message.
2015-01-22 04:35:17 +00:00
* @param aDeltaX The delta value for X direction. If the native
* message doesn't indicate X direction scrolling,
* this may be ignored.
2015-01-22 04:35:17 +00:00
* @param aDeltaY The delta value for Y direction. If the native
* message doesn't indicate Y direction scrolling,
* this may be ignored.
* @param aDeltaZ The delta value for Z direction. If the native
* message doesn't indicate Z direction scrolling,
* this may be ignored.
* @param aModifierFlags Must be values of Modifiers, or zero.
* @param aAdditionalFlags See nsIDOMWidnowUtils' consts and their
* document.
* @param aObserver The observer that will get notified once the
* events have been dispatched.
*/
virtual nsresult SynthesizeNativeMouseScrollEvent(
LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, double aDeltaX,
2015-01-22 04:35:17 +00:00
double aDeltaY, double aDeltaZ, uint32_t aModifierFlags,
uint32_t aAdditionalFlags, nsIObserver* aObserver) = 0;
/*
2015-01-22 04:35:17 +00:00
* TouchPointerState states for SynthesizeNativeTouchPoint. Match
* touch states in nsIDOMWindowUtils.idl.
*/
2015-01-22 04:35:17 +00:00
enum TouchPointerState {
// The pointer is in a hover state above the digitizer
TOUCH_HOVER = (1 << 0),
2015-01-22 04:35:17 +00:00
// The pointer is in contact with the digitizer
TOUCH_CONTACT = (1 << 1),
2015-01-22 04:35:17 +00:00
// The pointer has been removed from the digitizer detection area
TOUCH_REMOVE = (1 << 2),
// The pointer has been canceled. Will cancel any pending os level
2015-01-22 04:35:17 +00:00
// gestures that would triggered as a result of completion of the
// input sequence. This may not cancel moz platform related events
// that might get tirggered by input already delivered.
TOUCH_CANCEL = (1 << 3),
2015-01-22 04:35:17 +00:00
// ALL_BITS used for validity checking during IPC serialization
ALL_BITS = (1 << 4) - 1
2015-01-22 04:35:17 +00:00
};
/*
* TouchpadGesturePhase states for SynthesizeNativeTouchPadPinch and
* SynthesizeNativeTouchpadPan. Match phase states in nsIDOMWindowUtils.idl.
*/
enum TouchpadGesturePhase {
PHASE_BEGIN = 0,
PHASE_UPDATE = 1,
PHASE_END = 2
};
2015-01-22 04:35:17 +00:00
/*
* Create a new or update an existing touch pointer on the digitizer.
2015-01-22 04:35:17 +00:00
* To trigger os level gestures, individual touch points should
* transition through a complete set of touch states which should be
2015-01-22 04:35:17 +00:00
* sent as individual messages.
*
* @param aPointerId The touch point id to create or update.
2015-01-22 04:35:17 +00:00
* @param aPointerState one or more of the touch states listed above
* @param aPoint coords of this event
* @param aPressure 0.0 -> 1.0 float val indicating pressure
* @param aOrientation 0 -> 359 degree value indicating the
2015-01-22 04:35:17 +00:00
* orientation of the pointer. Use 90 for normal taps.
* @param aObserver The observer that will get notified once the events
* have been dispatched.
*/
virtual nsresult SynthesizeNativeTouchPoint(uint32_t aPointerId,
2015-01-22 04:35:17 +00:00
TouchPointerState aPointerState,
Bug 900750 - part 2: Make ModifierKeyState and VirtualKey treat AltGraph as new modifier and won't set Control and Alt state while AltGraph is active r=m_kato,smaug By the proposal from Google, <https://github.com/w3c/uievents/issues/147>, Chromium treat AltRight key as "AltGraph" modifier if the keyboard layout has AltGr key. When AltRight key is pressed with a keyboard layout which has AltGr key, modifiers should as following: 1. "keydown" for ControlLeft: ctrlKey: true, altKey: false, getModifierState("AltGraph"): false 2. "keydown" for AltRight: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 3. Some "keydown", "keypress" and "keyup" events: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 4. "keyup" for ControlLeft: ctrlKey: false, altKey: false, getModifierState("AltGraph"): true 5. "keyup" for AltRight: ctrlKey: false, altKey: false, getModifierState("AltGraph"): false So, only when the preceding "keydown" event for ControlLeft, ctrlKey should be set to true as usual. However, after AltRight key is pressed actually, we should treat "AltGraph" modifier is true and both ctrlKey and altKey should be set to false for web apps can handle text input normally. So, MODIFIER_ALTGRAPH and MODIFIER_CONTROL/MODIFIER_ALT should not be set at the same time. This patch makes ModifierKeyState have only MODIFIER_ALTGRAPH or MODIFIER_CONTROL/MODIFIER_ALT. Additionally, this patch makes VirtualKey::ShiftState treat "AltGraph" as a modifier. So, now, VirtualKey needs to convert ShiftState to index value when it accesses its mShiftStates array. Therefore, this patch adds VirtualKey::ToIndex() and make each VirtualKey method use it before accessing mShiftStates. Note that this patch also fixes bug of WinUtils::SetupKeyModifiersSequence(). The constructor of KeyPair takes 2 keycode values, but the second virtual keycode can have scancode to distinguish if the key is left or right. However, WinUtils::SetupKeyModifiersSequence() never sets scancode to KeyPair. Therefore, it fails to dispatch AltRight key event. MozReview-Commit-ID: 7ealxJH9KlZ --HG-- extra : rebase_source : 761bc4416222def020a0731d6ae7940ef074ebe0
2018-05-30 08:27:31 +00:00
LayoutDeviceIntPoint aPoint,
2015-01-22 04:35:17 +00:00
double aPointerPressure,
uint32_t aPointerOrientation,
nsIObserver* aObserver) = 0;
/*
* See nsIDOMWindowUtils.sendNativeTouchpadPinch().
*/
virtual nsresult SynthesizeNativeTouchPadPinch(
TouchpadGesturePhase aEventPhase, float aScale,
LayoutDeviceIntPoint aPoint, int32_t aModifierFlags) = 0;
2015-01-22 04:35:17 +00:00
/*
* Helper for simulating a simple tap event with one touch point. When
* aLongTap is true, simulates a native long tap with a duration equal to
* ui.click_hold_context_menus.delay. This pref is compatible with the
* apzc long tap duration. Defaults to 1.5 seconds.
* @param aObserver The observer that will get notified once the events
* have been dispatched.
2015-01-22 04:35:17 +00:00
*/
virtual nsresult SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint,
bool aLongTap,
nsIObserver* aObserver);
virtual nsresult SynthesizeNativePenInput(uint32_t aPointerId,
TouchPointerState aPointerState,
LayoutDeviceIntPoint aPoint,
double aPressure,
uint32_t aRotation, int32_t aTiltX,
int32_t aTiltY, int32_t aButton,
nsIObserver* aObserver) = 0;
2015-01-22 04:35:17 +00:00
/*
* Cancels all active simulated touch input points and pending long taps.
* Native widgets should track existing points such that they can clear the
* digitizer state when this call is made.
* @param aObserver The observer that will get notified once the touch
* sequence has been cleared.
2015-01-22 04:35:17 +00:00
*/
virtual nsresult ClearNativeTouchSequence(nsIObserver* aObserver);
/*
* Send a native event as if the user double tapped the touchpad with two
* fingers.
*/
virtual nsresult SynthesizeNativeTouchpadDoubleTap(
LayoutDeviceIntPoint aPoint, uint32_t aModifierFlags) = 0;
/*
* See nsIDOMWindowUtils.sendNativeTouchpadPan().
*/
virtual nsresult SynthesizeNativeTouchpadPan(TouchpadGesturePhase aEventPhase,
LayoutDeviceIntPoint aPoint,
double aDeltaX, double aDeltaY,
int32_t aModifierFlags) = 0;
2015-01-22 04:35:17 +00:00
virtual void StartAsyncScrollbarDrag(
const AsyncDragMetrics& aDragMetrics) = 0;
2015-01-22 04:35:17 +00:00
/**
* Notify APZ to start autoscrolling.
* @param aAnchorLocation the location of the autoscroll anchor
* @param aGuid identifies the scroll frame to be autoscrolled
* @return true if APZ has been successfully notified
2015-01-22 04:35:17 +00:00
*/
virtual bool StartAsyncAutoscroll(const ScreenPoint& aAnchorLocation,
const ScrollableLayerGuid& aGuid) = 0;
2015-01-22 04:35:17 +00:00
/**
* Notify APZ to stop autoscrolling.
* @param aGuid identifies the scroll frame which is being autoscrolled.
2015-01-22 04:35:17 +00:00
*/
virtual void StopAsyncAutoscroll(const ScrollableLayerGuid& aGuid) = 0;
virtual LayersId GetRootLayerTreeId() = 0;
// If this widget supports out-of-process compositing, it can override
// this method to provide additional information to the compositor.
virtual void GetCompositorWidgetInitData(
mozilla::widget::CompositorWidgetInitData* aInitData) {}
/**
* Setter/Getter of the system font setting for testing.
*/
virtual nsresult SetSystemFont(const nsCString& aFontName) {
return NS_ERROR_NOT_IMPLEMENTED;
}
virtual nsresult GetSystemFont(nsCString& aFontName) {
return NS_ERROR_NOT_IMPLEMENTED;
}
// Get rectangle of the screen where the window is placed.
// It's used to detect popup overflow under Wayland because
// Screenmanager does not work under it.
virtual nsRect GetPreferredPopupRect() {
NS_WARNING("GetPreferredPopupRect implemented only for wayland");
return nsRect(0, 0, 0, 0);
}
virtual void FlushPreferredPopupRect() {
NS_WARNING("FlushPreferredPopupRect implemented only for wayland");
return;
}
/**
* If this widget uses native pointer lock instead of warp-to-center
* (currently only GTK on Wayland), these methods provide access to that
* functionality.
*/
virtual void SetNativePointerLockCenter(
const LayoutDeviceIntPoint& aLockCenter) {}
virtual void LockNativePointer() {}
virtual void UnlockNativePointer() {}
/*
* Get safe area insets except to cutout.
* See https://drafts.csswg.org/css-env-1/#safe-area-insets.
*/
virtual mozilla::ScreenIntMargin GetSafeAreaInsets() const {
return mozilla::ScreenIntMargin();
}
2015-01-22 04:35:17 +00:00
private:
class LongTapInfo {
public:
LongTapInfo(int32_t aPointerId, LayoutDeviceIntPoint& aPoint,
mozilla::TimeDuration aDuration, nsIObserver* aObserver)
2015-01-22 04:35:17 +00:00
: mPointerId(aPointerId),
mPosition(aPoint),
mDuration(aDuration),
mObserver(aObserver),
2015-01-22 04:35:17 +00:00
mStamp(mozilla::TimeStamp::Now()) {}
int32_t mPointerId;
LayoutDeviceIntPoint mPosition;
2015-01-22 04:35:17 +00:00
mozilla::TimeDuration mDuration;
nsCOMPtr<nsIObserver> mObserver;
2015-01-22 04:35:17 +00:00
mozilla::TimeStamp mStamp;
};
static void OnLongTapTimerCallback(nsITimer* aTimer, void* aClosure);
static already_AddRefed<nsIBidiKeyboard> CreateBidiKeyboardContentProcess();
static already_AddRefed<nsIBidiKeyboard> CreateBidiKeyboardInner();
mozilla::UniquePtr<LongTapInfo> mLongTapTouchPoint;
2015-01-22 04:35:17 +00:00
nsCOMPtr<nsITimer> mLongTapTimer;
static int32_t sPointerIdCounter;
public:
/**
* If key events have not been handled by content or XBL handlers, they can
* be offered to the system (for custom application shortcuts set in system
* preferences, for example).
*/
virtual void PostHandleKeyEvent(mozilla::WidgetKeyboardEvent* aEvent);
2015-01-22 04:35:17 +00:00
/**
* Activates a native menu item at the position specified by the index
* string. The index string is a string of positive integers separated
* by the "|" (pipe) character. The last integer in the string represents
* the item index in a submenu located using the integers preceding it.
*
* Example: 1|0|4
* In this string, the first integer represents the top-level submenu
* in the native menu bar. Since the integer is 1, it is the second submeu
* in the native menu bar. Within that, the first item (index 0) is a
* submenu, and we want to activate the 5th item within that submenu.
*/
virtual nsresult ActivateNativeMenuItemAt(const nsAString& indexString) = 0;
2015-01-22 04:35:17 +00:00
/**
* This is used for native menu system testing.
*
* Updates a native menu at the position specified by the index string.
* The index string is a string of positive integers separated by the "|"
2015-01-22 04:35:17 +00:00
* (pipe) character.
*
* Example: 1|0|4
* In this string, the first integer represents the top-level submenu
* in the native menu bar. Since the integer is 1, it is the second submeu
* in the native menu bar. Within that, the first item (index 0) is a
* submenu, and we want to update submenu at index 4 within that submenu.
*
* If this is called with an empty string it forces a full reload of the
* menu system.
*/
virtual nsresult ForceUpdateNativeMenuAt(const nsAString& indexString) = 0;
/**
* This is used for testing macOS service menu code.
*
* @param aResult - the current text selection. Is empty if no selection.
* @return nsresult - whether or not aResult was assigned the selected text.
*/
[[nodiscard]] virtual nsresult GetSelectionAsPlaintext(nsAString& aResult) {
return NS_ERROR_NOT_IMPLEMENTED;
}
2015-01-22 04:35:17 +00:00
/**
* Notify IME of the specified notification.
*
* @return If the notification is mouse button event and it's consumed by
* IME, this returns NS_SUCCESS_EVENT_CONSUMED.
*/
virtual nsresult NotifyIME(const IMENotification& aIMENotification) = 0;
/**
* MaybeDispatchInitialFocusEvent will dispatch a focus event after creation
* of the widget, in the event that we were not able to observe and respond to
* the initial focus event. This is necessary for the early skeleton UI
* window, which is displayed and receives its initial focus event before we
* can actually respond to it.
*/
virtual void MaybeDispatchInitialFocusEvent() {}
2015-01-22 04:35:17 +00:00
/*
* Notifies the input context changes.
*/
virtual void SetInputContext(const InputContext& aContext,
const InputContextAction& aAction) = 0;
2015-01-22 04:35:17 +00:00
/*
* Get current input context.
*/
virtual InputContext GetInputContext() = 0;
/**
* Get native IME context. This is different from GetNativeData() with
* NS_RAW_NATIVE_IME_CONTEXT, the result is unique even if in a remote
* process.
*/
Bug 1453629 - nsIWidget::GetNativeIMEContext() should return pseudo IME context if TextInputProcessor has a composition on the widget r=m_kato Key of TextCompositionArrary to search composition on widget is native IME context. However, if TextInputProcessor dispatches composition events via TextEventDispatcher, TextEventDispatcher::InitEvent() sets native IME context of dispatching composition events to pseudo IME context (that's raw pointer of TextEventDispatcher and process ID). IMEStateManager::DispatchCompositionEvent() looks for existing TextComposition with native IME context stored in WidgetCompositionEvent before dispatching an event. However, after dispatching it, it looks for remaining TextComposition instance with widget stored in WidgetCompositionEvent. Then, TextCompositionArrary::IndexOf(nsIWidget*) will look for an instance with the result of nsIWidget::GetNativeIMEContext() and this never returns actual native IME context. Therefore, IMEStateManager::DispatchCompositionEvent() always fails to remove TextComposition instance from the array even after a test composition is finished. This patch moves nsIWidget::GetNativeIMEContext() to nsBaseWidget to refer nsBaseWidget::mTextEventDispatcher makes it return pseudo IME context if TextInputProcessor has input transaction. Therefore, IMEStateManager becomes always removes TextComposition from the array when every composition ends. MozReview-Commit-ID: H1PCtPjBYJR --HG-- extra : rebase_source : cbb3f3aae9954d65135d3840be8974fa30c4f7ff
2018-07-17 13:31:51 +00:00
virtual NativeIMEContext GetNativeIMEContext() = 0;
2015-01-22 04:35:17 +00:00
/*
* Given a WidgetKeyboardEvent, this method synthesizes a corresponding
* native (OS-level) event for it. This method allows tests to simulate
* keystrokes that trigger native key bindings (which require a native
* event).
*/
[[nodiscard]] virtual nsresult AttachNativeKeyEvent(
mozilla::WidgetKeyboardEvent& aEvent) = 0;
/**
* Retrieve edit commands when the key combination of aEvent is used
* in platform native applications.
2015-01-22 04:35:17 +00:00
*/
enum NativeKeyBindingsType : uint8_t {
2015-01-22 04:35:17 +00:00
NativeKeyBindingsForSingleLineEditor,
NativeKeyBindingsForMultiLineEditor,
NativeKeyBindingsForRichTextEditor
};
MOZ_CAN_RUN_SCRIPT virtual bool GetEditCommands(
NativeKeyBindingsType aType, const mozilla::WidgetKeyboardEvent& aEvent,
nsTArray<mozilla::CommandInt>& aCommands);
2015-01-22 04:35:17 +00:00
/*
Bug 1217700 part.1 nsIWidget should return reference to IMENotificationRequests r=m_kato IMEContentObserver may need to change notifications to send when TextInputProcessor begins input transaction. In current design, IMEContentObserver needs to retrieve IMENotificationRequests at every change. However, if nsIWidget returns a reference to its IMENotificationRequests, IMEContentObserver can call it only once. For that purpose, this patch changes nsIWidget::GetIMENotificationRequests() to nsIWidget::IMENotificationRequestsRef() and make it return |const IMENotificationRequests&|. However, if the lifetime of the instance of IMENotificationRequest is shorter than the widget instance's, it's dangerous. Therefore, it always returns TextEventDispatcher::mIMENotificationRequests. TextEventDispatcher's lifetime is longer than the widget. Therefore, this guarantees the lifetime. On the other hand, widget needs to update TextEventDispatcher::mIMENotificationRequests before calls of nsIWidget::IMENotificationRequestsRef(). Therefore, this patch makes TextEventDispatcher update proper IMENotificationRequests when it gets focus or starts new input transaction and clear mIMENotificationRequests when it loses focus. Note that TextEventDispatcher gets proper requests both from native text event dispatcher listener (typically, implemented by native IME handler class) and TextInputProcessor when TextInputProcessor has input transaction because even if TextInputProcessor overrides native IME, native IME still needs to know the content changes since they may get new input transaction after that. However, there may not be native IME handler in content process. If it runs in Android, PuppetWidget may have native IME handler because widget directly handles IME in e10s mode for Android. Otherwise, native IME handler is in its parent process. So, if TextInputHandler has input transaction in content process, PuppetWidget needs to behave as native event handler. Therefore, this patch makes PuppetWidget inherit TextEventDispatcherListener and implements PuppetWidget::IMENotificationRequestsRef(). MozReview-Commit-ID: 2SW3moONTOX --HG-- extra : rebase_source : d2634ada6c33dbf7a966fadb68608411ee24bfab
2017-04-14 16:35:58 +00:00
* Retrieves a reference to notification requests of IME. Note that the
* reference is valid while the nsIWidget instance is alive. So, if you
* need to store the reference for a long time, you need to grab the widget
* instance too.
2015-01-22 04:35:17 +00:00
*/
Bug 1217700 part.1 nsIWidget should return reference to IMENotificationRequests r=m_kato IMEContentObserver may need to change notifications to send when TextInputProcessor begins input transaction. In current design, IMEContentObserver needs to retrieve IMENotificationRequests at every change. However, if nsIWidget returns a reference to its IMENotificationRequests, IMEContentObserver can call it only once. For that purpose, this patch changes nsIWidget::GetIMENotificationRequests() to nsIWidget::IMENotificationRequestsRef() and make it return |const IMENotificationRequests&|. However, if the lifetime of the instance of IMENotificationRequest is shorter than the widget instance's, it's dangerous. Therefore, it always returns TextEventDispatcher::mIMENotificationRequests. TextEventDispatcher's lifetime is longer than the widget. Therefore, this guarantees the lifetime. On the other hand, widget needs to update TextEventDispatcher::mIMENotificationRequests before calls of nsIWidget::IMENotificationRequestsRef(). Therefore, this patch makes TextEventDispatcher update proper IMENotificationRequests when it gets focus or starts new input transaction and clear mIMENotificationRequests when it loses focus. Note that TextEventDispatcher gets proper requests both from native text event dispatcher listener (typically, implemented by native IME handler class) and TextInputProcessor when TextInputProcessor has input transaction because even if TextInputProcessor overrides native IME, native IME still needs to know the content changes since they may get new input transaction after that. However, there may not be native IME handler in content process. If it runs in Android, PuppetWidget may have native IME handler because widget directly handles IME in e10s mode for Android. Otherwise, native IME handler is in its parent process. So, if TextInputHandler has input transaction in content process, PuppetWidget needs to behave as native event handler. Therefore, this patch makes PuppetWidget inherit TextEventDispatcherListener and implements PuppetWidget::IMENotificationRequestsRef(). MozReview-Commit-ID: 2SW3moONTOX --HG-- extra : rebase_source : d2634ada6c33dbf7a966fadb68608411ee24bfab
2017-04-14 16:35:58 +00:00
const IMENotificationRequests& IMENotificationRequestsRef();
2015-01-22 04:35:17 +00:00
/*
* Call this method when a dialog is opened which has a default button.
* The button's rectangle should be supplied in aButtonRect.
*/
[[nodiscard]] virtual nsresult OnDefaultButtonLoaded(
const LayoutDeviceIntRect& aButtonRect) = 0;
2015-01-22 04:35:17 +00:00
/**
* Return true if this process shouldn't use platform widgets, and
* so should use PuppetWidgets instead. If this returns true, the
* result of creating and using a platform widget is undefined,
* and likely to end in crashes or other buggy behavior.
*/
static bool UsePuppetWidgets() { return XRE_IsContentProcess(); }
static already_AddRefed<nsIWidget> CreateTopLevelWindow();
static already_AddRefed<nsIWidget> CreateChildWindow();
2015-01-22 04:35:17 +00:00
/**
* Allocate and return a "puppet widget" that doesn't directly
* correlate to a platform widget; platform events and data must
* be fed to it. Currently used in content processes. NULL is
* returned if puppet widgets aren't supported in this build
* config, on this platform, or for this process type.
*
* This function is called "Create" to match CreateInstance().
* The returned widget must still be nsIWidget::Create()d.
*/
static already_AddRefed<nsIWidget> CreatePuppetWidget(
BrowserChild* aBrowserChild);
static already_AddRefed<nsIWidget> CreateHeadlessWidget();
2015-01-22 04:35:17 +00:00
/**
* Reparent this widget's native widget.
* @param aNewParent the native widget of aNewParent is the new native
* parent widget
*/
virtual void ReparentNativeWidget(nsIWidget* aNewParent) = 0;
2015-01-22 04:35:17 +00:00
/**
* Return true if widget has it's own GL context
*/
virtual bool HasGLContext() { return false; }
2015-01-22 04:35:17 +00:00
/**
* Returns true to indicate that this widget paints an opaque background
* that we want to be visible under the page, so layout should not force
* a default background.
*/
virtual bool WidgetPaintsBackground() { return false; }
virtual bool NeedsPaint() { return IsVisible() && !GetBounds().IsEmpty(); }
2015-01-22 04:35:17 +00:00
/**
* Get the natural bounds of this widget. This method is only
* meaningful for widgets for which Gecko implements screen
* rotation natively. When this is the case, GetBounds() returns
* the widget bounds taking rotation into account, and
* GetNaturalBounds() returns the bounds *not* taking rotation
* into account.
*
* No code outside of the composition pipeline should know or care
* about this. If you're not an agent of the compositor, you
* probably shouldn't call this method.
*/
virtual LayoutDeviceIntRect GetNaturalBounds() { return GetBounds(); }
2015-01-22 04:35:17 +00:00
/**
* Set size constraints on the window size such that it is never less than
* the specified minimum size and never larger than the specified maximum
* size. The size constraints are sizes of the outer rectangle including
* the window frame and title bar. Use 0 for an unconstrained minimum size
* and NS_MAXSIZE for an unconstrained maximum size. Note that this method
* does not necessarily change the size of a window to conform to this size,
* thus Resize should be called afterwards.
*
* @param aConstraints: the size constraints in device pixels
*/
virtual void SetSizeConstraints(const SizeConstraints& aConstraints) = 0;
2015-01-22 04:35:17 +00:00
/**
* Return the size constraints currently observed by the widget.
*
* @return the constraints in device pixels
*/
virtual const SizeConstraints GetSizeConstraints() = 0;
/**
* Apply the current size constraints to the given size.
*
* @param aWidth width to constrain
* @param aHeight height to constrain
*/
virtual void ConstrainSize(int32_t* aWidth, int32_t* aHeight) = 0;
2015-01-22 04:35:17 +00:00
/**
* If this is owned by a BrowserChild, return that. Otherwise return
2015-01-22 04:35:17 +00:00
* null.
*/
virtual BrowserChild* GetOwningBrowserChild() { return nullptr; }
2015-01-22 04:35:17 +00:00
/**
* If this isn't directly compositing to its window surface,
* return the compositor which is doing that on our behalf.
*/
virtual CompositorBridgeChild* GetRemoteRenderer() { return nullptr; }
/**
* Clear WebRender resources
*/
virtual void ClearCachedWebrenderResources() {}
/**
* If this widget has its own vsync source, return it, otherwise return
* nullptr. An example of such local source would be Wayland frame callbacks.
*/
virtual RefPtr<mozilla::gfx::VsyncSource> GetVsyncSource() { return nullptr; }
/**
* Returns true if the widget requires synchronous repaints on resize,
* false otherwise.
*/
virtual bool SynchronouslyRepaintOnResize() { return true; }
2015-01-22 04:35:17 +00:00
/**
* Some platforms (only cocoa right now) round widget coordinates to the
* nearest even pixels (see bug 892994), this function allows us to
* determine how widget coordinates will be rounded.
*/
virtual int32_t RoundsWidgetCoordinatesTo() { return 1; }
virtual void UpdateZoomConstraints(
const uint32_t& aPresShellId, const ScrollableLayerGuid::ViewID& aViewId,
const mozilla::Maybe<ZoomConstraints>& aConstraints){};
/**
* GetTextEventDispatcher() returns TextEventDispatcher belonging to the
* widget. Note that this never returns nullptr.
*/
virtual TextEventDispatcher* GetTextEventDispatcher() = 0;
/**
* GetNativeTextEventDispatcherListener() returns a
* TextEventDispatcherListener instance which is used when the widget
* instance handles native IME and/or keyboard events.
*/
virtual TextEventDispatcherListener*
GetNativeTextEventDispatcherListener() = 0;
virtual void ZoomToRect(const uint32_t& aPresShellId,
const ScrollableLayerGuid::ViewID& aViewId,
const CSSRect& aRect, const uint32_t& aFlags) = 0;
/**
* LookUpDictionary shows the dictionary for the word around current point.
*
* @param aText the word to look up dictiorary.
* @param aFontRangeArray text decoration of aText
* @param aIsVertical true if the word is vertical layout
* @param aPoint top-left point of aText
*/
virtual void LookUpDictionary(
const nsAString& aText,
const nsTArray<mozilla::FontRange>& aFontRangeArray,
const bool aIsVertical, const LayoutDeviceIntPoint& aPoint) {}
virtual void RequestFxrOutput() {
MOZ_ASSERT(false, "This function should only execute in Windows");
}
#if defined(MOZ_WIDGET_ANDROID)
/**
* RecvToolbarAnimatorMessageFromCompositor receive message from compositor
* thread.
*
* @param aMessage message being sent to Android UI thread.
*/
virtual void RecvToolbarAnimatorMessageFromCompositor(int32_t aMessage) = 0;
/**
* UpdateRootFrameMetrics steady state frame metrics send from compositor
* thread
*
* @param aScrollOffset page scroll offset value in screen pixels.
* @param aZoom current page zoom.
*/
virtual void UpdateRootFrameMetrics(const ScreenPoint& aScrollOffset,
const CSSToScreenScale& aZoom) = 0;
/**
* RecvScreenPixels Buffer containing the pixel from the frame buffer. Used
* for android robocop tests.
*
* @param aMem shared memory containing the frame buffer pixels.
* @param aSize size of the buffer in screen pixels.
*/
virtual void RecvScreenPixels(mozilla::ipc::Shmem&& aMem,
const ScreenIntSize& aSize,
bool aNeedsYFlip) = 0;
virtual void UpdateDynamicToolbarMaxHeight(mozilla::ScreenIntCoord aHeight) {}
virtual mozilla::ScreenIntCoord GetDynamicToolbarMaxHeight() const {
return 0;
}
#endif
static already_AddRefed<nsIBidiKeyboard> CreateBidiKeyboard();
2015-01-22 04:35:17 +00:00
/**
* Like GetDefaultScale, but taking into account only the system settings
* and ignoring Gecko preferences.
*/
virtual double GetDefaultScaleInternal() { return 1.0; }
/**
* Layout uses this to alert the widget to the client rect representing
* the window maximize button. An empty rect indicates there is no
* maximize button (for example, in fullscreen). This is only implemented
* on Windows.
*/
virtual void SetWindowButtonRect(WindowButtonType aButtonType,
const LayoutDeviceIntRect& aClientRect) {}
protected:
2015-01-22 04:35:17 +00:00
// keep the list of children. We also keep track of our siblings.
// The ownership model is as follows: parent holds a strong ref to
// the first element of the list, and each element holds a strong
// ref to the next element in the list. The prevsibling and
// lastchild pointers are weak, which is fine as long as they are
// maintained properly.
nsCOMPtr<nsIWidget> mFirstChild;
nsIWidget* MOZ_NON_OWNING_REF mLastChild;
2015-01-22 04:35:17 +00:00
nsCOMPtr<nsIWidget> mNextSibling;
nsIWidget* MOZ_NON_OWNING_REF mPrevSibling;
2015-01-22 04:35:17 +00:00
// When Destroy() is called, the sub class should set this true.
bool mOnDestroyCalled;
nsWindowType mWindowType;
int32_t mZIndex;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIWidget, NS_IWIDGET_IID)
#endif // nsIWidget_h__