зеркало из https://github.com/mozilla/gecko-dev.git
664 строки
28 KiB
C++
664 строки
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
|
|
};
|
|
|
|
/**
|
|
* A child window is a window with different style.
|
|
*/
|
|
class ChildWindow : public nsWindow {
|
|
|
|
public:
|
|
ChildWindow() {}
|
|
|
|
protected:
|
|
virtual DWORD WindowStyle();
|
|
};
|
|
|
|
#endif // Window_h__
|