mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-17 23:35:34 +00:00
6ea0979c0f
When we jump to fullscreen, the OS sends a WM_MOUSELEAVE, which we turn into a eMouseExitFromWidget. The eMouseEnterIntoWidget was previously only sent when the mouse moved into the widget, which required the mouse to move. When entering fullscreen, we want the eMouseEnterIntoWidget to happen right away.
671 lines
28 KiB
C++
671 lines
28 KiB
C++
/* -*- 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 Window_h__
|
|
#define Window_h__
|
|
|
|
/*
|
|
* nsWindow - Native window management and event handling.
|
|
*/
|
|
|
|
#include "mozilla/RefPtr.h"
|
|
#include "nsBaseWidget.h"
|
|
#include "nsWindowBase.h"
|
|
#include "nsdefs.h"
|
|
#include "nsIdleService.h"
|
|
#include "nsToolkit.h"
|
|
#include "nsString.h"
|
|
#include "nsTArray.h"
|
|
#include "gfxWindowsPlatform.h"
|
|
#include "gfxWindowsSurface.h"
|
|
#include "nsWindowDbg.h"
|
|
#include "cairo.h"
|
|
#include "nsITimer.h"
|
|
#include "nsRegion.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "nsMargin.h"
|
|
#include "nsRegionFwd.h"
|
|
|
|
#include "nsWinGesture.h"
|
|
#include "WinUtils.h"
|
|
#include "WindowHook.h"
|
|
#include "TaskbarWindowPreview.h"
|
|
|
|
#ifdef ACCESSIBILITY
|
|
#include "oleacc.h"
|
|
#include "mozilla/a11y/Accessible.h"
|
|
#endif
|
|
|
|
#include "nsUXThemeData.h"
|
|
#include "nsIDOMMouseEvent.h"
|
|
#include "nsIIdleServiceInternal.h"
|
|
|
|
#include "IMMHandler.h"
|
|
|
|
/**
|
|
* Forward class definitions
|
|
*/
|
|
|
|
class nsNativeDragTarget;
|
|
class nsIRollupListener;
|
|
class imgIContainer;
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
class NativeKey;
|
|
class WinCompositorWidget;
|
|
struct MSGResult;
|
|
} // namespace widget
|
|
} // namespacw mozilla;
|
|
|
|
/**
|
|
* Native WIN32 window wrapper.
|
|
*/
|
|
|
|
class nsWindow : public nsWindowBase
|
|
{
|
|
typedef mozilla::TimeStamp TimeStamp;
|
|
typedef mozilla::TimeDuration TimeDuration;
|
|
typedef mozilla::widget::WindowHook WindowHook;
|
|
typedef mozilla::widget::TaskbarWindowPreview TaskbarWindowPreview;
|
|
typedef mozilla::widget::NativeKey NativeKey;
|
|
typedef mozilla::widget::MSGResult MSGResult;
|
|
typedef mozilla::widget::IMEContext IMEContext;
|
|
|
|
public:
|
|
nsWindow();
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
|
|
friend class nsWindowGfx;
|
|
|
|
// nsWindowBase
|
|
virtual void InitEvent(mozilla::WidgetGUIEvent& aEvent,
|
|
LayoutDeviceIntPoint* aPoint = nullptr) override;
|
|
virtual WidgetEventTime CurrentMessageWidgetEventTime() const override;
|
|
virtual bool DispatchWindowEvent(mozilla::WidgetGUIEvent* aEvent) override;
|
|
virtual bool DispatchKeyboardEvent(mozilla::WidgetKeyboardEvent* aEvent) override;
|
|
virtual bool DispatchWheelEvent(mozilla::WidgetWheelEvent* aEvent) override;
|
|
virtual bool DispatchContentCommandEvent(mozilla::WidgetContentCommandEvent* aEvent) override;
|
|
virtual nsWindowBase* GetParentWindowBase(bool aIncludeOwner) override;
|
|
virtual bool IsTopLevelWidget() override { return mIsTopWidgetWindow; }
|
|
|
|
using nsWindowBase::DispatchPluginEvent;
|
|
|
|
// nsIWidget interface
|
|
using nsWindowBase::Create; // for Create signature not overridden here
|
|
virtual MOZ_MUST_USE nsresult Create(nsIWidget* aParent,
|
|
nsNativeWidget aNativeParent,
|
|
const LayoutDeviceIntRect& aRect,
|
|
nsWidgetInitData* aInitData = nullptr)
|
|
override;
|
|
virtual void Destroy() override;
|
|
NS_IMETHOD SetParent(nsIWidget *aNewParent) override;
|
|
virtual nsIWidget* GetParent(void) override;
|
|
virtual float GetDPI() override;
|
|
double GetDefaultScaleInternal() final;
|
|
int32_t LogToPhys(double aValue) final;
|
|
mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() final
|
|
{
|
|
if (mozilla::widget::WinUtils::IsPerMonitorDPIAware()) {
|
|
return mozilla::DesktopToLayoutDeviceScale(1.0);
|
|
} else {
|
|
return mozilla::DesktopToLayoutDeviceScale(GetDefaultScaleInternal());
|
|
}
|
|
}
|
|
|
|
NS_IMETHOD Show(bool bState) override;
|
|
virtual bool IsVisible() const override;
|
|
virtual void ConstrainPosition(bool aAllowSlop, int32_t *aX, int32_t *aY) override;
|
|
virtual void SetSizeConstraints(const SizeConstraints& aConstraints) override;
|
|
virtual const SizeConstraints GetSizeConstraints() override;
|
|
NS_IMETHOD Move(double aX, double aY) override;
|
|
NS_IMETHOD Resize(double aWidth, double aHeight, bool aRepaint) override;
|
|
NS_IMETHOD Resize(double aX, double aY, double aWidth, double aHeight, bool aRepaint) override;
|
|
NS_IMETHOD BeginResizeDrag(mozilla::WidgetGUIEvent* aEvent,
|
|
int32_t aHorizontal,
|
|
int32_t aVertical) override;
|
|
virtual void PlaceBehind(nsTopLevelWidgetZPlacement aPlacement, nsIWidget *aWidget, bool aActivate) override;
|
|
virtual void SetSizeMode(nsSizeMode aMode) override;
|
|
NS_IMETHOD Enable(bool aState) override;
|
|
virtual bool IsEnabled() const override;
|
|
NS_IMETHOD SetFocus(bool aRaise) override;
|
|
virtual LayoutDeviceIntRect GetBounds() override;
|
|
virtual LayoutDeviceIntRect GetScreenBounds() override;
|
|
virtual MOZ_MUST_USE nsresult GetRestoredBounds(LayoutDeviceIntRect& aRect) override;
|
|
virtual LayoutDeviceIntRect GetClientBounds() override;
|
|
virtual LayoutDeviceIntPoint GetClientOffset() override;
|
|
void SetBackgroundColor(const nscolor& aColor) override;
|
|
NS_IMETHOD SetCursor(imgIContainer* aCursor,
|
|
uint32_t aHotspotX, uint32_t aHotspotY) override;
|
|
NS_IMETHOD SetCursor(nsCursor aCursor) override;
|
|
virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations) override;
|
|
virtual bool PrepareForFullscreenTransition(nsISupports** aData) override;
|
|
virtual void PerformFullscreenTransition(FullscreenTransitionStage aStage,
|
|
uint16_t aDuration,
|
|
nsISupports* aData,
|
|
nsIRunnable* aCallback) override;
|
|
virtual nsresult MakeFullScreen(bool aFullScreen,
|
|
nsIScreen* aScreen = nullptr) override;
|
|
NS_IMETHOD HideWindowChrome(bool aShouldHide) override;
|
|
NS_IMETHOD Invalidate(bool aEraseBackground = false,
|
|
bool aUpdateNCArea = false,
|
|
bool aIncludeChildren = false);
|
|
NS_IMETHOD Invalidate(const LayoutDeviceIntRect& aRect);
|
|
virtual void* GetNativeData(uint32_t aDataType) override;
|
|
void SetNativeData(uint32_t aDataType, uintptr_t aVal) override;
|
|
virtual void FreeNativeData(void * data, uint32_t aDataType) override;
|
|
NS_IMETHOD SetTitle(const nsAString& aTitle) override;
|
|
NS_IMETHOD SetIcon(const nsAString& aIconSpec) override;
|
|
virtual LayoutDeviceIntPoint WidgetToScreenOffset() override;
|
|
virtual LayoutDeviceIntSize ClientToWindowSize(const LayoutDeviceIntSize& aClientSize) override;
|
|
NS_IMETHOD DispatchEvent(mozilla::WidgetGUIEvent* aEvent,
|
|
nsEventStatus& aStatus) override;
|
|
virtual void EnableDragDrop(bool aEnable) override;
|
|
virtual void CaptureMouse(bool aCapture) override;
|
|
virtual void CaptureRollupEvents(nsIRollupListener* aListener,
|
|
bool aDoCapture) override;
|
|
NS_IMETHOD GetAttention(int32_t aCycleCount) override;
|
|
virtual bool HasPendingInputEvent() override;
|
|
virtual LayerManager* GetLayerManager(PLayerTransactionChild* aShadowManager = nullptr,
|
|
LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
|
|
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
|
|
NS_IMETHOD OnDefaultButtonLoaded(const LayoutDeviceIntRect& aButtonRect) override;
|
|
virtual nsresult SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
|
|
int32_t aNativeKeyCode,
|
|
uint32_t aModifierFlags,
|
|
const nsAString& aCharacters,
|
|
const nsAString& aUnmodifiedCharacters,
|
|
nsIObserver* aObserver) override;
|
|
virtual nsresult SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
|
|
uint32_t aNativeMessage,
|
|
uint32_t aModifierFlags,
|
|
nsIObserver* aObserver) override;
|
|
|
|
virtual nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
|
|
nsIObserver* aObserver) override
|
|
{ return SynthesizeNativeMouseEvent(aPoint, MOUSEEVENTF_MOVE, 0, aObserver); }
|
|
|
|
virtual nsresult SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint,
|
|
uint32_t aNativeMessage,
|
|
double aDeltaX,
|
|
double aDeltaY,
|
|
double aDeltaZ,
|
|
uint32_t aModifierFlags,
|
|
uint32_t aAdditionalFlags,
|
|
nsIObserver* aObserver) override;
|
|
NS_IMETHOD_(void) SetInputContext(const InputContext& aContext,
|
|
const InputContextAction& aAction) override;
|
|
NS_IMETHOD_(InputContext) GetInputContext() override;
|
|
NS_IMETHOD_(TextEventDispatcherListener*)
|
|
GetNativeTextEventDispatcherListener() override;
|
|
#ifdef MOZ_XUL
|
|
virtual void SetTransparencyMode(nsTransparencyMode aMode) override;
|
|
virtual nsTransparencyMode GetTransparencyMode() override;
|
|
virtual void UpdateOpaqueRegion(const LayoutDeviceIntRegion& aOpaqueRegion) override;
|
|
#endif // MOZ_XUL
|
|
virtual nsIMEUpdatePreference GetIMEUpdatePreference() override;
|
|
NS_IMETHOD SetNonClientMargins(LayoutDeviceIntMargin& aMargins) override;
|
|
void SetDrawsInTitlebar(bool aState) override;
|
|
virtual void UpdateWindowDraggingRegion(const LayoutDeviceIntRegion& aRegion) override;
|
|
|
|
virtual void UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries) override;
|
|
virtual uint32_t GetMaxTouchPoints() const override;
|
|
|
|
/**
|
|
* Event helpers
|
|
*/
|
|
virtual bool DispatchMouseEvent(
|
|
mozilla::EventMessage aEventMessage,
|
|
WPARAM wParam,
|
|
LPARAM lParam,
|
|
bool aIsContextMenuKey = false,
|
|
int16_t aButton =
|
|
mozilla::WidgetMouseEvent::eLeftButton,
|
|
uint16_t aInputSource =
|
|
nsIDOMMouseEvent::MOZ_SOURCE_MOUSE,
|
|
uint16_t aPointerId = 0);
|
|
virtual bool DispatchWindowEvent(mozilla::WidgetGUIEvent* aEvent,
|
|
nsEventStatus& aStatus);
|
|
void DispatchPendingEvents();
|
|
bool DispatchPluginEvent(UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam,
|
|
bool aDispatchPendingEvents);
|
|
|
|
void SuppressBlurEvents(bool aSuppress); // Called from nsFilePicker
|
|
bool BlurEventsSuppressed();
|
|
#ifdef ACCESSIBILITY
|
|
/**
|
|
* Return an accessible associated with the window.
|
|
*/
|
|
mozilla::a11y::Accessible* GetAccessible();
|
|
#endif // ACCESSIBILITY
|
|
|
|
/**
|
|
* Window utilities
|
|
*/
|
|
nsWindow* GetTopLevelWindow(bool aStopOnDialogOrPopup);
|
|
WNDPROC GetPrevWindowProc() { return mPrevWndProc; }
|
|
WindowHook& GetWindowHook() { return mWindowHook; }
|
|
nsWindow* GetParentWindow(bool aIncludeOwner);
|
|
// Get an array of all nsWindow*s on the main thread.
|
|
static nsTArray<nsWindow*> EnumAllWindows();
|
|
|
|
/**
|
|
* Misc.
|
|
*/
|
|
virtual bool AutoErase(HDC dc);
|
|
bool WidgetTypeSupportsAcceleration() override;
|
|
|
|
void ForcePresent();
|
|
|
|
/**
|
|
* AssociateDefaultIMC() associates or disassociates the default IMC for
|
|
* the window.
|
|
*
|
|
* @param aAssociate TRUE, associates the default IMC with the window.
|
|
* Otherwise, disassociates the default IMC from the
|
|
* window.
|
|
* @return TRUE if this method associated the default IMC with
|
|
* disassociated window or disassociated the default IMC
|
|
* from associated window.
|
|
* Otherwise, i.e., if this method did nothing actually,
|
|
* FALSE.
|
|
*/
|
|
bool AssociateDefaultIMC(bool aAssociate);
|
|
|
|
bool HasTaskbarIconBeenCreated() { return mHasTaskbarIconBeenCreated; }
|
|
// Called when either the nsWindow or an nsITaskbarTabPreview receives the noticiation that this window
|
|
// has its icon placed on the taskbar.
|
|
void SetHasTaskbarIconBeenCreated(bool created = true) { mHasTaskbarIconBeenCreated = created; }
|
|
|
|
// Getter/setter for the nsITaskbarWindowPreview for this nsWindow
|
|
already_AddRefed<nsITaskbarWindowPreview> GetTaskbarPreview() {
|
|
nsCOMPtr<nsITaskbarWindowPreview> preview(do_QueryReferent(mTaskbarPreview));
|
|
return preview.forget();
|
|
}
|
|
void SetTaskbarPreview(nsITaskbarWindowPreview *preview) { mTaskbarPreview = do_GetWeakReference(preview); }
|
|
|
|
virtual void ReparentNativeWidget(nsIWidget* aNewParent) override;
|
|
|
|
// Open file picker tracking
|
|
void PickerOpen();
|
|
void PickerClosed();
|
|
|
|
bool const DestroyCalled() { return mDestroyCalled; }
|
|
|
|
bool IsPopup();
|
|
virtual bool ShouldUseOffMainThreadCompositing() override;
|
|
|
|
const IMEContext& DefaultIMC() const { return mDefaultIMC; }
|
|
|
|
virtual void SetCandidateWindowForPlugin(
|
|
const mozilla::widget::CandidateWindowPosition&
|
|
aPosition) override;
|
|
virtual void DefaultProcOfPluginEvent(
|
|
const mozilla::WidgetPluginEvent& aEvent) override;
|
|
virtual nsresult OnWindowedPluginKeyEvent(
|
|
const mozilla::NativeEventData& aKeyEventData,
|
|
nsIKeyEventInPluginCallback* aCallback) override;
|
|
|
|
void GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData) override;
|
|
bool IsTouchWindow() const { return mTouchWindow; }
|
|
|
|
protected:
|
|
virtual ~nsWindow();
|
|
|
|
virtual void WindowUsesOMTC() override;
|
|
virtual void RegisterTouchWindow() override;
|
|
|
|
// A magic number to identify the FAKETRACKPOINTSCROLLABLE window created
|
|
// when the trackpoint hack is enabled.
|
|
enum { eFakeTrackPointScrollableID = 0x46545053 };
|
|
|
|
// Used for displayport suppression during window resize
|
|
enum ResizeState {
|
|
NOT_RESIZING,
|
|
IN_SIZEMOVE,
|
|
RESIZING,
|
|
MOVING
|
|
};
|
|
|
|
/**
|
|
* Callbacks
|
|
*/
|
|
static LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
static LRESULT CALLBACK WindowProcInternal(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
|
|
static BOOL CALLBACK BroadcastMsgToChildren(HWND aWnd, LPARAM aMsg);
|
|
static BOOL CALLBACK BroadcastMsg(HWND aTopWindow, LPARAM aMsg);
|
|
static BOOL CALLBACK DispatchStarvedPaints(HWND aTopWindow, LPARAM aMsg);
|
|
static BOOL CALLBACK RegisterTouchForDescendants(HWND aTopWindow, LPARAM aMsg);
|
|
static BOOL CALLBACK UnregisterTouchForDescendants(HWND aTopWindow, LPARAM aMsg);
|
|
static LRESULT CALLBACK MozSpecialMsgFilter(int code, WPARAM wParam, LPARAM lParam);
|
|
static LRESULT CALLBACK MozSpecialWndProc(int code, WPARAM wParam, LPARAM lParam);
|
|
static LRESULT CALLBACK MozSpecialMouseProc(int code, WPARAM wParam, LPARAM lParam);
|
|
static VOID CALLBACK HookTimerForPopups( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );
|
|
static BOOL CALLBACK ClearResourcesCallback(HWND aChild, LPARAM aParam);
|
|
static BOOL CALLBACK EnumAllChildWindProc(HWND aWnd, LPARAM aParam);
|
|
static BOOL CALLBACK EnumAllThreadWindowProc(HWND aWnd, LPARAM aParam);
|
|
|
|
/**
|
|
* Window utilities
|
|
*/
|
|
LPARAM lParamToScreen(LPARAM lParam);
|
|
LPARAM lParamToClient(LPARAM lParam);
|
|
virtual void SubclassWindow(BOOL bState);
|
|
bool CanTakeFocus();
|
|
bool UpdateNonClientMargins(int32_t aSizeMode = -1, bool aReflowWindow = true);
|
|
void UpdateGetWindowInfoCaptionStatus(bool aActiveCaption);
|
|
void ResetLayout();
|
|
void InvalidateNonClientRegion();
|
|
HRGN ExcludeNonClientFromPaintRegion(HRGN aRegion);
|
|
static const wchar_t* GetMainWindowClass();
|
|
bool HasGlass() const {
|
|
return mTransparencyMode == eTransparencyGlass ||
|
|
mTransparencyMode == eTransparencyBorderlessGlass;
|
|
}
|
|
HWND GetOwnerWnd() const
|
|
{
|
|
return ::GetWindow(mWnd, GW_OWNER);
|
|
}
|
|
bool IsOwnerForegroundWindow() const
|
|
{
|
|
HWND owner = GetOwnerWnd();
|
|
return owner && owner == ::GetForegroundWindow();
|
|
}
|
|
bool IsPopup() const
|
|
{
|
|
return mWindowType == eWindowType_popup;
|
|
}
|
|
|
|
|
|
/**
|
|
* Event processing helpers
|
|
*/
|
|
void DispatchFocusToTopLevelWindow(bool aIsActivate);
|
|
bool DispatchStandardEvent(mozilla::EventMessage aMsg);
|
|
void RelayMouseEvent(UINT aMsg, WPARAM wParam, LPARAM lParam);
|
|
virtual bool ProcessMessage(UINT msg, WPARAM &wParam,
|
|
LPARAM &lParam, LRESULT *aRetValue);
|
|
bool ExternalHandlerProcessMessage(
|
|
UINT aMessage, WPARAM& aWParam,
|
|
LPARAM& aLParam, MSGResult& aResult);
|
|
bool ProcessMessageForPlugin(const MSG &aMsg,
|
|
MSGResult& aResult);
|
|
LRESULT ProcessCharMessage(const MSG &aMsg,
|
|
bool *aEventDispatched);
|
|
LRESULT ProcessKeyUpMessage(const MSG &aMsg,
|
|
bool *aEventDispatched);
|
|
LRESULT ProcessKeyDownMessage(const MSG &aMsg,
|
|
bool *aEventDispatched);
|
|
static bool EventIsInsideWindow(nsWindow* aWindow);
|
|
// Convert nsEventStatus value to a windows boolean
|
|
static bool ConvertStatus(nsEventStatus aStatus);
|
|
static void PostSleepWakeNotification(const bool aIsSleepMode);
|
|
int32_t ClientMarginHitTestPoint(int32_t mx, int32_t my);
|
|
TimeStamp GetMessageTimeStamp(LONG aEventTime) const;
|
|
static void UpdateFirstEventTime(DWORD aEventTime);
|
|
void FinishLiveResizing(ResizeState aNewState);
|
|
|
|
/**
|
|
* Event handlers
|
|
*/
|
|
virtual void OnDestroy() override;
|
|
virtual bool OnResize(nsIntRect &aWindowRect);
|
|
bool OnGesture(WPARAM wParam, LPARAM lParam);
|
|
bool OnTouch(WPARAM wParam, LPARAM lParam);
|
|
bool OnHotKey(WPARAM wParam, LPARAM lParam);
|
|
bool OnPaint(HDC aDC, uint32_t aNestingLevel);
|
|
void OnWindowPosChanged(WINDOWPOS* wp);
|
|
void OnWindowPosChanging(LPWINDOWPOS& info);
|
|
void OnSysColorChanged();
|
|
void OnDPIChanged(int32_t x, int32_t y,
|
|
int32_t width, int32_t height);
|
|
|
|
/**
|
|
* Function that registers when the user has been active (used for detecting
|
|
* when the user is idle).
|
|
*/
|
|
void UserActivity();
|
|
|
|
int32_t GetHeight(int32_t aProposedHeight);
|
|
const wchar_t* GetWindowClass() const;
|
|
const wchar_t* GetWindowPopupClass() const;
|
|
virtual DWORD WindowStyle();
|
|
DWORD WindowExStyle();
|
|
|
|
// This method registers the given window class, and returns the class name.
|
|
const wchar_t* RegisterWindowClass(const wchar_t* aClassName,
|
|
UINT aExtraStyle,
|
|
LPWSTR aIconID) const;
|
|
|
|
/**
|
|
* XP and Vista theming support for windows with rounded edges
|
|
*/
|
|
void ClearThemeRegion();
|
|
void SetThemeRegion();
|
|
|
|
/**
|
|
* Popup hooks
|
|
*/
|
|
static void ScheduleHookTimer(HWND aWnd, UINT aMsgId);
|
|
static void RegisterSpecialDropdownHooks();
|
|
static void UnregisterSpecialDropdownHooks();
|
|
static bool GetPopupsToRollup(nsIRollupListener* aRollupListener,
|
|
uint32_t* aPopupsToRollup);
|
|
static bool NeedsToHandleNCActivateDelayed(HWND aWnd);
|
|
static bool DealWithPopups(HWND inWnd, UINT inMsg, WPARAM inWParam, LPARAM inLParam, LRESULT* outResult);
|
|
|
|
/**
|
|
* Window transparency helpers
|
|
*/
|
|
#ifdef MOZ_XUL
|
|
private:
|
|
void SetWindowTranslucencyInner(nsTransparencyMode aMode);
|
|
nsTransparencyMode GetWindowTranslucencyInner() const { return mTransparencyMode; }
|
|
void UpdateGlass();
|
|
protected:
|
|
#endif // MOZ_XUL
|
|
|
|
static bool IsAsyncResponseEvent(UINT aMsg, LRESULT& aResult);
|
|
void IPCWindowProcHandler(UINT& msg, WPARAM& wParam, LPARAM& lParam);
|
|
|
|
/**
|
|
* Misc.
|
|
*/
|
|
void StopFlashing();
|
|
static bool IsTopLevelMouseExit(HWND aWnd);
|
|
virtual nsresult SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,
|
|
bool aIntersectWithExisting) override;
|
|
nsIntRegion GetRegionToPaint(bool aForceFullRepaint,
|
|
PAINTSTRUCT ps, HDC aDC);
|
|
static void ActivateOtherWindowHelper(HWND aWnd);
|
|
void ClearCachedResources();
|
|
nsIWidgetListener* GetPaintListener();
|
|
|
|
already_AddRefed<SourceSurface> CreateScrollSnapshot() override;
|
|
|
|
struct ScrollSnapshot
|
|
{
|
|
RefPtr<gfxWindowsSurface> surface;
|
|
bool surfaceHasSnapshot = false;
|
|
RECT clip;
|
|
};
|
|
|
|
ScrollSnapshot* EnsureSnapshotSurface(ScrollSnapshot& aSnapshotData,
|
|
const mozilla::gfx::IntSize& aSize);
|
|
|
|
ScrollSnapshot mFullSnapshot;
|
|
ScrollSnapshot mPartialSnapshot;
|
|
ScrollSnapshot* mCurrentSnapshot = nullptr;
|
|
|
|
already_AddRefed<SourceSurface>
|
|
GetFallbackScrollSnapshot(const RECT& aRequiredClip);
|
|
|
|
protected:
|
|
nsCOMPtr<nsIWidget> mParent;
|
|
nsIntSize mLastSize;
|
|
nsIntPoint mLastPoint;
|
|
HWND mWnd;
|
|
HWND mTransitionWnd;
|
|
WNDPROC mPrevWndProc;
|
|
HBRUSH mBrush;
|
|
IMEContext mDefaultIMC;
|
|
bool mIsTopWidgetWindow;
|
|
bool mInDtor;
|
|
bool mIsVisible;
|
|
bool mUnicodeWidget;
|
|
bool mPainting;
|
|
bool mTouchWindow;
|
|
bool mDisplayPanFeedback;
|
|
bool mHideChrome;
|
|
bool mIsRTL;
|
|
bool mFullscreenMode;
|
|
bool mMousePresent;
|
|
bool mDestroyCalled;
|
|
uint32_t mBlurSuppressLevel;
|
|
DWORD_PTR mOldStyle;
|
|
DWORD_PTR mOldExStyle;
|
|
nsNativeDragTarget* mNativeDragTarget;
|
|
HKL mLastKeyboardLayout;
|
|
nsSizeMode mOldSizeMode;
|
|
nsSizeMode mLastSizeMode;
|
|
WindowHook mWindowHook;
|
|
uint32_t mPickerDisplayCount;
|
|
HICON mIconSmall;
|
|
HICON mIconBig;
|
|
static bool sDropShadowEnabled;
|
|
static uint32_t sInstanceCount;
|
|
static TriStateBool sCanQuit;
|
|
static nsWindow* sCurrentWindow;
|
|
static BOOL sIsOleInitialized;
|
|
static HCURSOR sHCursor;
|
|
static imgIContainer* sCursorImgContainer;
|
|
static bool sSwitchKeyboardLayout;
|
|
static bool sJustGotDeactivate;
|
|
static bool sJustGotActivate;
|
|
static bool sIsInMouseCapture;
|
|
static int sTrimOnMinimize;
|
|
|
|
// Always use the helper method to read this property. See bug 603793.
|
|
static TriStateBool sHasBogusPopupsDropShadowOnMultiMonitor;
|
|
static bool HasBogusPopupsDropShadowOnMultiMonitor();
|
|
|
|
// Non-client margin settings
|
|
// Pre-calculated outward offset applied to default frames
|
|
LayoutDeviceIntMargin mNonClientOffset;
|
|
// Margins set by the owner
|
|
LayoutDeviceIntMargin mNonClientMargins;
|
|
// Margins we'd like to set once chrome is reshown:
|
|
LayoutDeviceIntMargin mFutureMarginsOnceChromeShows;
|
|
// Indicates we need to apply margins once toggling chrome into showing:
|
|
bool mFutureMarginsToUse;
|
|
|
|
// Indicates custom frames are enabled
|
|
bool mCustomNonClient;
|
|
// Cached copy of L&F's resize border
|
|
int32_t mHorResizeMargin;
|
|
int32_t mVertResizeMargin;
|
|
// Height of the caption plus border
|
|
int32_t mCaptionHeight;
|
|
|
|
double mDefaultScale;
|
|
|
|
nsCOMPtr<nsIIdleServiceInternal> mIdleService;
|
|
|
|
// Draggable titlebar region maintained by UpdateWindowDraggingRegion
|
|
LayoutDeviceIntRegion mDraggableRegion;
|
|
|
|
// Hook Data Memebers for Dropdowns. sProcessHook Tells the
|
|
// hook methods whether they should be processing the hook
|
|
// messages.
|
|
static HHOOK sMsgFilterHook;
|
|
static HHOOK sCallProcHook;
|
|
static HHOOK sCallMouseHook;
|
|
static bool sProcessHook;
|
|
static UINT sRollupMsgId;
|
|
static HWND sRollupMsgWnd;
|
|
static UINT sHookTimerId;
|
|
|
|
// Mouse Clicks - static variable definitions for figuring
|
|
// out 1 - 3 Clicks.
|
|
static POINT sLastMousePoint;
|
|
static POINT sLastMouseMovePoint;
|
|
static LONG sLastMouseDownTime;
|
|
static LONG sLastClickCount;
|
|
static BYTE sLastMouseButton;
|
|
|
|
// Graphics
|
|
HDC mPaintDC; // only set during painting
|
|
|
|
LayoutDeviceIntRect mLastPaintBounds;
|
|
|
|
ResizeState mResizeState;
|
|
|
|
// Transparency
|
|
#ifdef MOZ_XUL
|
|
nsTransparencyMode mTransparencyMode;
|
|
nsIntRegion mPossiblyTransparentRegion;
|
|
MARGINS mGlassMargins;
|
|
#endif // MOZ_XUL
|
|
|
|
// Win7 Gesture processing and management
|
|
nsWinGesture mGesture;
|
|
|
|
// Weak ref to the nsITaskbarWindowPreview associated with this window
|
|
nsWeakPtr mTaskbarPreview;
|
|
// True if the taskbar (possibly through the tab preview) tells us that the
|
|
// icon has been created on the taskbar.
|
|
bool mHasTaskbarIconBeenCreated;
|
|
|
|
// Indicates that mouse events should be ignored and pass through to the
|
|
// window below. This is currently only used for popups.
|
|
bool mMouseTransparent;
|
|
|
|
// Whether we're in the process of sending a WM_SETTEXT ourselves
|
|
bool mSendingSetText;
|
|
|
|
// The point in time at which the last paint completed. We use this to avoid
|
|
// painting too rapidly in response to frequent input events.
|
|
TimeStamp mLastPaintEndTime;
|
|
|
|
// Caching for hit test results
|
|
POINT mCachedHitTestPoint;
|
|
TimeStamp mCachedHitTestTime;
|
|
int32_t mCachedHitTestResult;
|
|
|
|
RefPtr<mozilla::widget::WinCompositorWidget> mBasicLayersSurface;
|
|
|
|
static bool sNeedsToInitMouseWheelSettings;
|
|
static void InitMouseWheelScrollData();
|
|
|
|
double mSizeConstraintsScale; // scale in effect when setting constraints
|
|
|
|
// Used to remember the wParam (i.e. currently pressed modifier keys)
|
|
// and lParam (i.e. last mouse position) in screen coordinates from
|
|
// the previous mouse-exit. Static since it is not
|
|
// associated with a particular widget (since we exited the widget).
|
|
static WPARAM sMouseExitwParam;
|
|
static LPARAM sMouseExitlParamScreen;
|
|
};
|
|
|
|
/**
|
|
* A child window is a window with different style.
|
|
*/
|
|
class ChildWindow : public nsWindow {
|
|
|
|
public:
|
|
ChildWindow() {}
|
|
|
|
protected:
|
|
virtual DWORD WindowStyle();
|
|
};
|
|
|
|
#endif // Window_h__
|