The Tor Browser: comparison widget/gtk/nsWindow.cpp

--1:000000000000
+:96409c8858d4
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+*/
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TextEvents.h"
+#include <algorithm>
+#include "prlink.h"
+#include "nsGTKToolkit.h"
+#include "nsIRollupListener.h"
+#include "nsIDOMNode.h"
+#include "nsWidgetsCID.h"
+#include "nsDragService.h"
+#include "nsIWidgetListener.h"
+#include "nsGtkKeyUtils.h"
+#include "nsGtkCursors.h"
+#include <gtk/gtk.h>
+#if (MOZ_WIDGET_GTK == 3)
+#include <gtk/gtkx.h>
+#endif
+#ifdef MOZ_X11
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/XShm.h>
+#include <X11/extensions/shape.h>
+#if (MOZ_WIDGET_GTK == 3)
+#include <gdk/gdkkeysyms-compat.h>
+#endif
+#ifdef AIX
+#include <X11/keysym.h>
+#else
+#include <X11/XF86keysym.h>
+#endif
+#if (MOZ_WIDGET_GTK == 2)
+#include "gtk2xtbin.h"
+#endif
+#endif /* MOZ_X11 */
+#include <gdk/gdkkeysyms.h>
+#if (MOZ_WIDGET_GTK == 2)
+#include <gtk/gtkprivate.h>
+#endif
+#include "nsGkAtoms.h"
+#ifdef MOZ_ENABLE_STARTUP_NOTIFICATION
+#define SN_API_NOT_YET_FROZEN
+#include <startup-notification-1.0/libsn/sn.h>
+#endif
+#include "mozilla/Likely.h"
+#include "mozilla/Preferences.h"
+#include "nsIPrefService.h"
+#include "nsIGConfService.h"
+#include "nsIServiceManager.h"
+#include "nsIStringBundle.h"
+#include "nsGfxCIID.h"
+#include "nsGtkUtils.h"
+#include "nsIObserverService.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "nsIIdleServiceInternal.h"
+#include "nsIPropertyBag2.h"
+#include "GLContext.h"
+#include "gfx2DGlue.h"
+#ifdef ACCESSIBILITY
+#include "mozilla/a11y/Accessible.h"
+#include "mozilla/a11y/Platform.h"
+#include "nsAccessibilityService.h"
+using namespace mozilla;
+using namespace mozilla::widget;
+#endif
+/* For SetIcon */
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsXPIDLString.h"
+#include "nsIFile.h"
+/* SetCursor(imgIContainer*) */
+#include <gdk/gdk.h>
+#include <wchar.h>
+#include "imgIContainer.h"
+#include "nsGfxCIID.h"
+#include "nsImageToPixbuf.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsAutoPtr.h"
+#include "ClientLayerManager.h"
+extern "C" {
+#define PIXMAN_DONT_DEFINE_STDINT
+#include "pixman.h"
+}
+#include "gfxPlatformGtk.h"
+#include "gfxContext.h"
+#include "gfxImageSurface.h"
+#include "gfxUtils.h"
+#include "Layers.h"
+#include "GLContextProvider.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/layers/CompositorParent.h"
+#ifdef MOZ_X11
+#include "gfxXlibSurface.h"
+#include "cairo-xlib.h"
+#endif
+#include "nsShmImage.h"
+#include "nsIDOMWheelEvent.h"
+#include "NativeKeyBindings.h"
+#include "nsWindow.h"
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::widget;
+using namespace mozilla::layers;
+using mozilla::gl::GLContext;
+// Don't put more than this many rects in the dirty region, just fluff
+// out to the bounding-box if there are more
+#define MAX_RECTS_IN_REGION 100
+const gint kEvents = GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK |
+GDK_VISIBILITY_NOTIFY_MASK |
+GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
+GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+GDK_SCROLL_MASK |
+GDK_POINTER_MOTION_MASK;
+/* utility functions */
+static bool       is_mouse_in_window(GdkWindow* aWindow,
+gdouble aMouseX, gdouble aMouseY);
+static nsWindow  *get_window_for_gtk_widget(GtkWidget *widget);
+static nsWindow  *get_window_for_gdk_window(GdkWindow *window);
+static GtkWidget *get_gtk_widget_for_gdk_window(GdkWindow *window);
+static GdkCursor *get_gtk_cursor(nsCursor aCursor);
+static GdkWindow *get_inner_gdk_window (GdkWindow *aWindow,
+gint x, gint y,
+gint *retx, gint *rety);
+static inline bool is_context_menu_key(const WidgetKeyboardEvent& inKeyEvent);
+static int    is_parent_ungrab_enter(GdkEventCrossing *aEvent);
+static int    is_parent_grab_leave(GdkEventCrossing *aEvent);
+static void GetBrandName(nsXPIDLString& brandName);
+/* callbacks from widgets */
+#if (MOZ_WIDGET_GTK == 2)
+static gboolean expose_event_cb           (GtkWidget *widget,
+GdkEventExpose *event);
+#else
+static gboolean expose_event_cb           (GtkWidget *widget,
+cairo_t *rect);
+#endif
+static gboolean configure_event_cb        (GtkWidget *widget,
+GdkEventConfigure *event);
+static void     container_unrealize_cb    (GtkWidget *widget);
+static void     size_allocate_cb          (GtkWidget *widget,
+GtkAllocation *allocation);
+static gboolean delete_event_cb           (GtkWidget *widget,
+GdkEventAny *event);
+static gboolean enter_notify_event_cb     (GtkWidget *widget,
+GdkEventCrossing *event);
+static gboolean leave_notify_event_cb     (GtkWidget *widget,
+GdkEventCrossing *event);
+static gboolean motion_notify_event_cb    (GtkWidget *widget,
+GdkEventMotion *event);
+static gboolean button_press_event_cb     (GtkWidget *widget,
+GdkEventButton *event);
+static gboolean button_release_event_cb   (GtkWidget *widget,
+GdkEventButton *event);
+static gboolean focus_in_event_cb         (GtkWidget *widget,
+GdkEventFocus *event);
+static gboolean focus_out_event_cb        (GtkWidget *widget,
+GdkEventFocus *event);
+static gboolean key_press_event_cb        (GtkWidget *widget,
+GdkEventKey *event);
+static gboolean key_release_event_cb      (GtkWidget *widget,
+GdkEventKey *event);
+static gboolean scroll_event_cb           (GtkWidget *widget,
+GdkEventScroll *event);
+static gboolean visibility_notify_event_cb(GtkWidget *widget,
+GdkEventVisibility *event);
+static void     hierarchy_changed_cb      (GtkWidget *widget,
+GtkWidget *previous_toplevel);
+static gboolean window_state_event_cb     (GtkWidget *widget,
+GdkEventWindowState *event);
+static void     theme_changed_cb          (GtkSettings *settings,
+GParamSpec *pspec,
+nsWindow *data);
+static nsWindow* GetFirstNSWindowForGDKWindow (GdkWindow *aGdkWindow);
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#ifdef MOZ_X11
+static GdkFilterReturn popup_take_focus_filter (GdkXEvent *gdk_xevent,
+GdkEvent *event,
+gpointer data);
+static GdkFilterReturn plugin_window_filter_func (GdkXEvent *gdk_xevent,
+GdkEvent *event,
+gpointer data);
+static GdkFilterReturn plugin_client_message_filter (GdkXEvent *xevent,
+GdkEvent *event,
+gpointer data);
+#endif /* MOZ_X11 */
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+static gboolean drag_motion_event_cb      (GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+guint aTime,
+gpointer aData);
+static void     drag_leave_event_cb       (GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+guint aTime,
+gpointer aData);
+static gboolean drag_drop_event_cb        (GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+guint aTime,
+gpointer aData);
+static void    drag_data_received_event_cb(GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+GtkSelectionData  *aSelectionData,
+guint aInfo,
+guint32 aTime,
+gpointer aData);
+/* initialization static functions */
+static nsresult    initialize_prefs        (void);
+static guint32 sLastUserInputTime = GDK_CURRENT_TIME;
+static guint32 sRetryGrabTime;
+static NS_DEFINE_IID(kCDragServiceCID,  NS_DRAGSERVICE_CID);
+// The window from which the focus manager asks us to dispatch key events.
+static nsWindow         *gFocusWindow          = nullptr;
+static bool              gBlockActivateEvent   = false;
+static bool              gGlobalsInitialized   = false;
+static bool              gRaiseWindows         = true;
+static nsWindow         *gPluginFocusWindow    = nullptr;
+#define NS_WINDOW_TITLE_MAX_LENGTH 4095
+// If after selecting profile window, the startup fail, please refer to
+// http://bugzilla.gnome.org/show_bug.cgi?id=88940
+// needed for imgIContainer cursors
+// GdkDisplay* was added in 2.2
+typedef struct _GdkDisplay GdkDisplay;
+#define kWindowPositionSlop 20
+// cursor cache
+static GdkCursor *gCursorCache[eCursorCount];
+static GtkWidget *gInvisibleContainer = nullptr;
+// Sometimes this actually also includes the state of the modifier keys, but
+// only the button state bits are used.
+static guint gButtonState;
+// nsAutoRef<pixman_region32> uses nsSimpleRef<> to know how to automatically
+// destroy regions.
+template <>
+class nsSimpleRef<pixman_region32> : public pixman_region32 {
+protected:
+typedef pixman_region32 RawRef;
+nsSimpleRef() { data = nullptr; }
+nsSimpleRef(const RawRef &aRawRef) : pixman_region32(aRawRef) { }
+static void Release(pixman_region32& region) {
+pixman_region32_fini(&region);
+}
+// Whether this needs to be released:
+bool HaveResource() const { return data != nullptr; }
+pixman_region32& get() { return *this; }
+};
+static inline int32_t
+GetBitmapStride(int32_t width)
+{
+#if defined(MOZ_X11) || (MOZ_WIDGET_GTK == 2)
+return (width+7)/8;
+#else
+return cairo_format_stride_for_width(CAIRO_FORMAT_A1, width);
+#endif
+}
+static inline bool TimestampIsNewerThan(guint32 a, guint32 b)
+{
+// Timestamps are just the least significant bits of a monotonically
+// increasing function, and so the use of unsigned overflow arithmetic.
+return a - b <= G_MAXUINT32/2;
+}
+static void
+UpdateLastInputEventTime(void *aGdkEvent)
+{
+nsCOMPtr<nsIIdleServiceInternal> idleService =
+do_GetService("@mozilla.org/widget/idleservice;1");
+if (idleService) {
+idleService->ResetIdleTimeOut(0);
+}
+guint timestamp = gdk_event_get_time(static_cast<GdkEvent*>(aGdkEvent));
+if (timestamp == GDK_CURRENT_TIME)
+return;
+sLastUserInputTime = timestamp;
+}
+nsWindow::nsWindow()
+{
+mIsTopLevel       = false;
+mIsDestroyed      = false;
+mNeedsResize      = false;
+mNeedsMove        = false;
+mListenForResizes = false;
+mIsShown          = false;
+mNeedsShow        = false;
+mEnabled          = true;
+mCreated          = false;
+mContainer           = nullptr;
+mGdkWindow           = nullptr;
+mShell               = nullptr;
+mHasMappedToplevel   = false;
+mIsFullyObscured     = false;
+mRetryPointerGrab    = false;
+mWindowType          = eWindowType_child;
+mSizeState           = nsSizeMode_Normal;
+mLastSizeMode        = nsSizeMode_Normal;
+mSizeConstraints.mMaxSize = GetSafeWindowSize(mSizeConstraints.mMaxSize);
+#ifdef MOZ_X11
+mOldFocusWindow      = 0;
+#endif /* MOZ_X11 */
+mPluginType          = PluginType_NONE;
+if (!gGlobalsInitialized) {
+gGlobalsInitialized = true;
+// It's OK if either of these fail, but it may not be one day.
+initialize_prefs();
+}
+mLastMotionPressure = 0;
+#ifdef ACCESSIBILITY
+mRootAccessible  = nullptr;
+#endif
+mIsTransparent = false;
+mTransparencyBitmap = nullptr;
+mTransparencyBitmapWidth  = 0;
+mTransparencyBitmapHeight = 0;
+}
+nsWindow::~nsWindow()
+{
+LOG(("nsWindow::~nsWindow() [%p]\n", (void *)this));
+delete[] mTransparencyBitmap;
+mTransparencyBitmap = nullptr;
+Destroy();
+}
+/* static */ void
+nsWindow::ReleaseGlobals()
+{
+for (uint32_t i = 0; i < ArrayLength(gCursorCache); ++i) {
+if (gCursorCache[i]) {
+gdk_cursor_unref(gCursorCache[i]);
+gCursorCache[i] = nullptr;
+}
+}
+}
+NS_IMPL_ISUPPORTS_INHERITED(nsWindow, nsBaseWidget,
+nsISupportsWeakReference)
+void
+nsWindow::CommonCreate(nsIWidget *aParent, bool aListenForResizes)
+{
+mParent = aParent;
+mListenForResizes = aListenForResizes;
+mCreated = true;
+}
+void
+nsWindow::DispatchActivateEvent(void)
+{
+NS_ASSERTION(mContainer || mIsDestroyed,
+"DispatchActivateEvent only intended for container windows");
+#ifdef ACCESSIBILITY
+DispatchActivateEventAccessible();
+#endif //ACCESSIBILITY
+if (mWidgetListener)
+mWidgetListener->WindowActivated();
+}
+void
+nsWindow::DispatchDeactivateEvent(void)
+{
+if (mWidgetListener)
+mWidgetListener->WindowDeactivated();
+#ifdef ACCESSIBILITY
+DispatchDeactivateEventAccessible();
+#endif //ACCESSIBILITY
+}
+void
+nsWindow::DispatchResized(int32_t aWidth, int32_t aHeight)
+{
+nsIWidgetListener *listeners[] =
+{ mWidgetListener, mAttachedWidgetListener };
+for (size_t i = 0; i < ArrayLength(listeners); ++i) {
+if (listeners[i]) {
+listeners[i]->WindowResized(this, aWidth, aHeight);
+}
+}
+}
+nsresult
+nsWindow::DispatchEvent(WidgetGUIEvent* aEvent, nsEventStatus& aStatus)
+{
+#ifdef DEBUG
+debug_DumpEvent(stdout, aEvent->widget, aEvent,
+nsAutoCString("something"), 0);
+#endif
+aStatus = nsEventStatus_eIgnore;
+nsIWidgetListener* listener =
+mAttachedWidgetListener ? mAttachedWidgetListener : mWidgetListener;
+if (listener) {
+aStatus = listener->HandleEvent(aEvent, mUseAttachedEvents);
+}
+return NS_OK;
+}
+void
+nsWindow::OnDestroy(void)
+{
+if (mOnDestroyCalled)
+return;
+mOnDestroyCalled = true;
+// Prevent deletion.
+nsCOMPtr<nsIWidget> kungFuDeathGrip = this;
+// release references to children, device context, toolkit + app shell
+nsBaseWidget::OnDestroy();
+// Remove association between this object and its parent and siblings.
+nsBaseWidget::Destroy();
+mParent = nullptr;
+NotifyWindowDestroyed();
+}
+bool
+nsWindow::AreBoundsSane(void)
+{
+if (mBounds.width > 0 && mBounds.height > 0)
+return true;
+return false;
+}
+static GtkWidget*
+EnsureInvisibleContainer()
+{
+if (!gInvisibleContainer) {
+// GtkWidgets need to be anchored to a GtkWindow to be realized (to
+// have a window).  Using GTK_WINDOW_POPUP rather than
+// GTK_WINDOW_TOPLEVEL in the hope that POPUP results in less
+// initialization and window manager interaction.
+GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP);
+gInvisibleContainer = moz_container_new();
+gtk_container_add(GTK_CONTAINER(window), gInvisibleContainer);
+gtk_widget_realize(gInvisibleContainer);
+}
+return gInvisibleContainer;
+}
+static void
+CheckDestroyInvisibleContainer()
+{
+NS_PRECONDITION(gInvisibleContainer, "oh, no");
+if (!gdk_window_peek_children(gtk_widget_get_window(gInvisibleContainer))) {
+// No children, so not in use.
+// Make sure to destroy the GtkWindow also.
+gtk_widget_destroy(gtk_widget_get_parent(gInvisibleContainer));
+gInvisibleContainer = nullptr;
+}
+}
+// Change the containing GtkWidget on a sub-hierarchy of GdkWindows belonging
+// to aOldWidget and rooted at aWindow, and reparent any child GtkWidgets of
+// the GdkWindow hierarchy to aNewWidget.
+static void
+SetWidgetForHierarchy(GdkWindow *aWindow,
+GtkWidget *aOldWidget,
+GtkWidget *aNewWidget)
+{
+gpointer data;
+gdk_window_get_user_data(aWindow, &data);
+if (data != aOldWidget) {
+if (!GTK_IS_WIDGET(data))
+return;
+GtkWidget* widget = static_cast<GtkWidget*>(data);
+if (gtk_widget_get_parent(widget) != aOldWidget)
+return;
+// This window belongs to a child widget, which will no longer be a
+// child of aOldWidget.
+gtk_widget_reparent(widget, aNewWidget);
+return;
+}
+GList *children = gdk_window_get_children(aWindow);
+for(GList *list = children; list; list = list->next) {
+SetWidgetForHierarchy(GDK_WINDOW(list->data), aOldWidget, aNewWidget);
+}
+g_list_free(children);
+gdk_window_set_user_data(aWindow, aNewWidget);
+}
+// Walk the list of child windows and call destroy on them.
+void
+nsWindow::DestroyChildWindows()
+{
+if (!mGdkWindow)
+return;
+while (GList *children = gdk_window_peek_children(mGdkWindow)) {
+GdkWindow *child = GDK_WINDOW(children->data);
+nsWindow *kid = get_window_for_gdk_window(child);
+if (kid) {
+kid->Destroy();
+} else {
+// This child is not an nsWindow.
+// Destroy the child GtkWidget.
+gpointer data;
+gdk_window_get_user_data(child, &data);
+if (GTK_IS_WIDGET(data)) {
+gtk_widget_destroy(static_cast<GtkWidget*>(data));
+}
+}
+}
+}
+NS_IMETHODIMP
+nsWindow::Destroy(void)
+{
+if (mIsDestroyed || !mCreated)
+return NS_OK;
+LOG(("nsWindow::Destroy [%p]\n", (void *)this));
+mIsDestroyed = true;
+mCreated = false;
+/** Need to clean our LayerManager up while still alive */
+if (mLayerManager) {
+mLayerManager->Destroy();
+}
+mLayerManager = nullptr;
+// It is safe to call DestroyeCompositor several times (here and
+// in the parent class) since it will take effect only once.
+// The reason we call it here is because on gtk platforms we need
+// to destroy the compositor before we destroy the gdk window (which
+// destroys the the gl context attached to it).
+DestroyCompositor();
+ClearCachedResources();
+g_signal_handlers_disconnect_by_func(gtk_settings_get_default(),
+FuncToGpointer(theme_changed_cb),
+this);
+nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener();
+if (rollupListener) {
+nsCOMPtr<nsIWidget> rollupWidget = rollupListener->GetRollupWidget();
+if (static_cast<nsIWidget *>(this) == rollupWidget) {
+rollupListener->Rollup(0, nullptr, nullptr);
+}
+}
+// dragService will be null after shutdown of the service manager.
+nsDragService *dragService = nsDragService::GetInstance();
+if (dragService && this == dragService->GetMostRecentDestWindow()) {
+dragService->ScheduleLeaveEvent();
+}
+NativeShow(false);
+if (mIMModule) {
+mIMModule->OnDestroyWindow(this);
+}
+// make sure that we remove ourself as the focus window
+if (gFocusWindow == this) {
+LOGFOCUS(("automatically losing focus...\n"));
+gFocusWindow = nullptr;
+}
+#if (MOZ_WIDGET_GTK == 2) && defined(MOZ_X11)
+// make sure that we remove ourself as the plugin focus window
+if (gPluginFocusWindow == this) {
+gPluginFocusWindow->LoseNonXEmbedPluginFocus();
+}
+#endif /* MOZ_X11 && MOZ_WIDGET_GTK2 */
+// Destroy thebes surface now. Badness can happen if we destroy
+// the surface after its X Window.
+mThebesSurface = nullptr;
+GtkWidget *owningWidget = GetMozContainerWidget();
+if (mShell) {
+gtk_widget_destroy(mShell);
+mShell = nullptr;
+mContainer = nullptr;
+NS_ABORT_IF_FALSE(!mGdkWindow,
+"mGdkWindow should be NULL when mContainer is destroyed");
+}
+else if (mContainer) {
+gtk_widget_destroy(GTK_WIDGET(mContainer));
+mContainer = nullptr;
+NS_ABORT_IF_FALSE(!mGdkWindow,
+"mGdkWindow should be NULL when mContainer is destroyed");
+}
+else if (mGdkWindow) {
+// Destroy child windows to ensure that their mThebesSurfaces are
+// released and to remove references from GdkWindows back to their
+// container widget.  (OnContainerUnrealize() does this when the
+// MozContainer widget is destroyed.)
+DestroyChildWindows();
+gdk_window_set_user_data(mGdkWindow, nullptr);
+g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", nullptr);
+gdk_window_destroy(mGdkWindow);
+mGdkWindow = nullptr;
+}
+if (gInvisibleContainer && owningWidget == gInvisibleContainer) {
+CheckDestroyInvisibleContainer();
+}
+#ifdef ACCESSIBILITY
+if (mRootAccessible) {
+mRootAccessible = nullptr;
+}
+#endif
+// Save until last because OnDestroy() may cause us to be deleted.
+OnDestroy();
+return NS_OK;
+}
+nsIWidget *
+nsWindow::GetParent(void)
+{
+return mParent;
+}
+float
+nsWindow::GetDPI()
+{
+Display *dpy = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+int defaultScreen = DefaultScreen(dpy);
+double heightInches = DisplayHeightMM(dpy, defaultScreen)/MM_PER_INCH_FLOAT;
+if (heightInches < 0.25) {
+// Something's broken, but we'd better not crash.
+return 96.0f;
+}
+return float(DisplayHeight(dpy, defaultScreen)/heightInches);
+}
+NS_IMETHODIMP
+nsWindow::SetParent(nsIWidget *aNewParent)
+{
+if (mContainer || !mGdkWindow) {
+NS_NOTREACHED("nsWindow::SetParent called illegally");
+return NS_ERROR_NOT_IMPLEMENTED;
+}
+nsCOMPtr<nsIWidget> kungFuDeathGrip = this;
+if (mParent) {
+mParent->RemoveChild(this);
+}
+mParent = aNewParent;
+GtkWidget* oldContainer = GetMozContainerWidget();
+if (!oldContainer) {
+// The GdkWindows have been destroyed so there is nothing else to
+// reparent.
+NS_ABORT_IF_FALSE(gdk_window_is_destroyed(mGdkWindow),
+"live GdkWindow with no widget");
+return NS_OK;
+}
+if (aNewParent) {
+aNewParent->AddChild(this);
+ReparentNativeWidget(aNewParent);
+} else {
+// aNewParent is nullptr, but reparent to a hidden window to avoid
+// destroying the GdkWindow and its descendants.
+// An invisible container widget is needed to hold descendant
+// GtkWidgets.
+GtkWidget* newContainer = EnsureInvisibleContainer();
+GdkWindow* newParentWindow = gtk_widget_get_window(newContainer);
+ReparentNativeWidgetInternal(aNewParent, newContainer, newParentWindow,
+oldContainer);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::ReparentNativeWidget(nsIWidget* aNewParent)
+{
+NS_PRECONDITION(aNewParent, "");
+NS_ASSERTION(!mIsDestroyed, "");
+NS_ASSERTION(!static_cast<nsWindow*>(aNewParent)->mIsDestroyed, "");
+GtkWidget* oldContainer = GetMozContainerWidget();
+if (!oldContainer) {
+// The GdkWindows have been destroyed so there is nothing else to
+// reparent.
+NS_ABORT_IF_FALSE(gdk_window_is_destroyed(mGdkWindow),
+"live GdkWindow with no widget");
+return NS_OK;
+}
+NS_ABORT_IF_FALSE(!gdk_window_is_destroyed(mGdkWindow),
+"destroyed GdkWindow with widget");
+nsWindow* newParent = static_cast<nsWindow*>(aNewParent);
+GdkWindow* newParentWindow = newParent->mGdkWindow;
+GtkWidget* newContainer = newParent->GetMozContainerWidget();
+GtkWindow* shell = GTK_WINDOW(mShell);
+if (shell && gtk_window_get_transient_for(shell)) {
+GtkWindow* topLevelParent =
+GTK_WINDOW(gtk_widget_get_toplevel(newContainer));
+gtk_window_set_transient_for(shell, topLevelParent);
+}
+ReparentNativeWidgetInternal(aNewParent, newContainer, newParentWindow,
+oldContainer);
+return NS_OK;
+}
+void
+nsWindow::ReparentNativeWidgetInternal(nsIWidget* aNewParent,
+GtkWidget* aNewContainer,
+GdkWindow* aNewParentWindow,
+GtkWidget* aOldContainer)
+{
+if (!aNewContainer) {
+// The new parent GdkWindow has been destroyed.
+NS_ABORT_IF_FALSE(!aNewParentWindow ||
+gdk_window_is_destroyed(aNewParentWindow),
+"live GdkWindow with no widget");
+Destroy();
+} else {
+if (aNewContainer != aOldContainer) {
+NS_ABORT_IF_FALSE(!gdk_window_is_destroyed(aNewParentWindow),
+"destroyed GdkWindow with widget");
+SetWidgetForHierarchy(mGdkWindow, aOldContainer, aNewContainer);
+if (aOldContainer == gInvisibleContainer) {
+CheckDestroyInvisibleContainer();
+}
+}
+if (!mIsTopLevel) {
+gdk_window_reparent(mGdkWindow, aNewParentWindow, mBounds.x,
+mBounds.y);
+}
+}
+nsWindow* newParent = static_cast<nsWindow*>(aNewParent);
+bool parentHasMappedToplevel =
+newParent && newParent->mHasMappedToplevel;
+if (mHasMappedToplevel != parentHasMappedToplevel) {
+SetHasMappedToplevel(parentHasMappedToplevel);
+}
+}
+NS_IMETHODIMP
+nsWindow::SetModal(bool aModal)
+{
+LOG(("nsWindow::SetModal [%p] %d\n", (void *)this, aModal));
+if (mIsDestroyed)
+return aModal ? NS_ERROR_NOT_AVAILABLE : NS_OK;
+if (!mIsTopLevel || !mShell)
+return NS_ERROR_FAILURE;
+gtk_window_set_modal(GTK_WINDOW(mShell), aModal ? TRUE : FALSE);
+return NS_OK;
+}
+// nsIWidget method, which means IsShown.
+bool
+nsWindow::IsVisible() const
+{
+return mIsShown;
+}
+NS_IMETHODIMP
+nsWindow::ConstrainPosition(bool aAllowSlop, int32_t *aX, int32_t *aY)
+{
+if (mIsTopLevel && mShell) {
+int32_t screenWidth = gdk_screen_width();
+int32_t screenHeight = gdk_screen_height();
+if (aAllowSlop) {
+if (*aX < (kWindowPositionSlop - mBounds.width))
+*aX = kWindowPositionSlop - mBounds.width;
+if (*aX > (screenWidth - kWindowPositionSlop))
+*aX = screenWidth - kWindowPositionSlop;
+if (*aY < (kWindowPositionSlop - mBounds.height))
+*aY = kWindowPositionSlop - mBounds.height;
+if (*aY > (screenHeight - kWindowPositionSlop))
+*aY = screenHeight - kWindowPositionSlop;
+} else {
+if (*aX < 0)
+*aX = 0;
+if (*aX > (screenWidth - mBounds.width))
+*aX = screenWidth - mBounds.width;
+if (*aY < 0)
+*aY = 0;
+if (*aY > (screenHeight - mBounds.height))
+*aY = screenHeight - mBounds.height;
+}
+}
+return NS_OK;
+}
+void nsWindow::SetSizeConstraints(const SizeConstraints& aConstraints)
+{
+mSizeConstraints.mMinSize = GetSafeWindowSize(aConstraints.mMinSize);
+mSizeConstraints.mMaxSize = GetSafeWindowSize(aConstraints.mMaxSize);
+if (mShell) {
+GdkGeometry geometry;
+geometry.min_width = mSizeConstraints.mMinSize.width;
+geometry.min_height = mSizeConstraints.mMinSize.height;
+geometry.max_width = mSizeConstraints.mMaxSize.width;
+geometry.max_height = mSizeConstraints.mMaxSize.height;
+uint32_t hints = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
+gtk_window_set_geometry_hints(GTK_WINDOW(mShell), nullptr,
+&geometry, GdkWindowHints(hints));
+}
+}
+NS_IMETHODIMP
+nsWindow::Show(bool aState)
+{
+if (aState == mIsShown)
+return NS_OK;
+// Clear our cached resources when the window is hidden.
+if (mIsShown && !aState) {
+ClearCachedResources();
+}
+mIsShown = aState;
+LOG(("nsWindow::Show [%p] state %d\n", (void *)this, aState));
+if (aState) {
+// Now that this window is shown, mHasMappedToplevel needs to be
+// tracked on viewable descendants.
+SetHasMappedToplevel(mHasMappedToplevel);
+}
+// Ok, someone called show on a window that isn't sized to a sane
+// value.  Mark this window as needing to have Show() called on it
+// and return.
+if ((aState && !AreBoundsSane()) || !mCreated) {
+LOG(("\tbounds are insane or window hasn't been created yet\n"));
+mNeedsShow = true;
+return NS_OK;
+}
+// If someone is hiding this widget, clear any needing show flag.
+if (!aState)
+mNeedsShow = false;
+// If someone is showing this window and it needs a resize then
+// resize the widget.
+if (aState) {
+if (mNeedsMove) {
+NativeResize(mBounds.x, mBounds.y, mBounds.width, mBounds.height,
+false);
+} else if (mNeedsResize) {
+NativeResize(mBounds.width, mBounds.height, false);
+}
+}
+#ifdef ACCESSIBILITY
+if (aState && a11y::ShouldA11yBeEnabled())
+CreateRootAccessible();
+#endif
+NativeShow(aState);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::Resize(double aWidth, double aHeight, bool aRepaint)
+{
+CSSToLayoutDeviceScale scale = BoundsUseDisplayPixels() ? GetDefaultScale()
+: CSSToLayoutDeviceScale(1.0);
+int32_t width = NSToIntRound(scale.scale * aWidth);
+int32_t height = NSToIntRound(scale.scale * aHeight);
+ConstrainSize(&width, &height);
+// For top-level windows, aWidth and aHeight should possibly be
+// interpreted as frame bounds, but NativeResize treats these as window
+// bounds (Bug 581866).
+mBounds.SizeTo(width, height);
+if (!mCreated)
+return NS_OK;
+// There are several cases here that we need to handle, based on a
+// matrix of the visibility of the widget, the sanity of this resize
+// and whether or not the widget was previously sane.
+// Has this widget been set to visible?
+if (mIsShown) {
+// Are the bounds sane?
+if (AreBoundsSane()) {
+// Yep?  Resize the window
+//Maybe, the toplevel has moved
+// Note that if the widget needs to be positioned because its
+// size was previously insane in Resize(x,y,w,h), then we need
+// to set the x and y here too, because the widget wasn't
+// moved back then
+if (mNeedsMove)
+NativeResize(mBounds.x, mBounds.y,
+mBounds.width, mBounds.height, aRepaint);
+else
+NativeResize(mBounds.width, mBounds.height, aRepaint);
+// Does it need to be shown because it was previously insane?
+if (mNeedsShow)
+NativeShow(true);
+}
+else {
+// If someone has set this so that the needs show flag is false
+// and it needs to be hidden, update the flag and hide the
+// window.  This flag will be cleared the next time someone
+// hides the window or shows it.  It also prevents us from
+// calling NativeShow(false) excessively on the window which
+// causes unneeded X traffic.
+if (!mNeedsShow) {
+mNeedsShow = true;
+NativeShow(false);
+}
+}
+}
+// If the widget hasn't been shown, mark the widget as needing to be
+// resized before it is shown.
+else {
+if (AreBoundsSane() && mListenForResizes) {
+// For widgets that we listen for resizes for (widgets created
+// with native parents) we apparently _always_ have to resize.  I
+// dunno why, but apparently we're lame like that.
+NativeResize(width, height, aRepaint);
+}
+else {
+mNeedsResize = true;
+}
+}
+NotifyRollupGeometryChange();
+// send a resize notification if this is a toplevel
+if (mIsTopLevel || mListenForResizes) {
+DispatchResized(width, height);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::Resize(double aX, double aY, double aWidth, double aHeight,
+bool aRepaint)
+{
+CSSToLayoutDeviceScale scale = BoundsUseDisplayPixels() ? GetDefaultScale()
+: CSSToLayoutDeviceScale(1.0);
+int32_t width = NSToIntRound(scale.scale * aWidth);
+int32_t height = NSToIntRound(scale.scale * aHeight);
+ConstrainSize(&width, &height);
+int32_t x = NSToIntRound(scale.scale * aX);
+int32_t y = NSToIntRound(scale.scale * aY);
+mBounds.x = x;
+mBounds.y = y;
+mBounds.SizeTo(width, height);
+mNeedsMove = true;
+if (!mCreated)
+return NS_OK;
+// There are several cases here that we need to handle, based on a
+// matrix of the visibility of the widget, the sanity of this resize
+// and whether or not the widget was previously sane.
+// Has this widget been set to visible?
+if (mIsShown) {
+// Are the bounds sane?
+if (AreBoundsSane()) {
+// Yep?  Resize the window
+NativeResize(x, y, width, height, aRepaint);
+// Does it need to be shown because it was previously insane?
+if (mNeedsShow)
+NativeShow(true);
+}
+else {
+// If someone has set this so that the needs show flag is false
+// and it needs to be hidden, update the flag and hide the
+// window.  This flag will be cleared the next time someone
+// hides the window or shows it.  It also prevents us from
+// calling NativeShow(false) excessively on the window which
+// causes unneeded X traffic.
+if (!mNeedsShow) {
+mNeedsShow = true;
+NativeShow(false);
+}
+}
+}
+// If the widget hasn't been shown, mark the widget as needing to be
+// resized before it is shown
+else {
+if (AreBoundsSane() && mListenForResizes){
+// For widgets that we listen for resizes for (widgets created
+// with native parents) we apparently _always_ have to resize.  I
+// dunno why, but apparently we're lame like that.
+NativeResize(x, y, width, height, aRepaint);
+}
+else {
+mNeedsResize = true;
+}
+}
+NotifyRollupGeometryChange();
+if (mIsTopLevel || mListenForResizes) {
+DispatchResized(width, height);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::Enable(bool aState)
+{
+mEnabled = aState;
+return NS_OK;
+}
+bool
+nsWindow::IsEnabled() const
+{
+return mEnabled;
+}
+NS_IMETHODIMP
+nsWindow::Move(double aX, double aY)
+{
+LOG(("nsWindow::Move [%p] %f %f\n", (void *)this,
+aX, aY));
+CSSToLayoutDeviceScale scale = BoundsUseDisplayPixels() ? GetDefaultScale()
+: CSSToLayoutDeviceScale(1.0);
+int32_t x = NSToIntRound(aX * scale.scale);
+int32_t y = NSToIntRound(aY * scale.scale);
+if (mWindowType == eWindowType_toplevel ||
+mWindowType == eWindowType_dialog) {
+SetSizeMode(nsSizeMode_Normal);
+}
+// Since a popup window's x/y coordinates are in relation to to
+// the parent, the parent might have moved so we always move a
+// popup window.
+if (x == mBounds.x && y == mBounds.y &&
+mWindowType != eWindowType_popup)
+return NS_OK;
+// XXX Should we do some AreBoundsSane check here?
+mBounds.x = x;
+mBounds.y = y;
+if (!mCreated)
+return NS_OK;
+mNeedsMove = false;
+if (mIsTopLevel) {
+gtk_window_move(GTK_WINDOW(mShell), x, y);
+}
+else if (mGdkWindow) {
+gdk_window_move(mGdkWindow, x, y);
+}
+NotifyRollupGeometryChange();
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::PlaceBehind(nsTopLevelWidgetZPlacement  aPlacement,
+nsIWidget                  *aWidget,
+bool                        aActivate)
+{
+return NS_ERROR_NOT_IMPLEMENTED;
+}
+void
+nsWindow::SetZIndex(int32_t aZIndex)
+{
+nsIWidget* oldPrev = GetPrevSibling();
+nsBaseWidget::SetZIndex(aZIndex);
+if (GetPrevSibling() == oldPrev) {
+return;
+}
+NS_ASSERTION(!mContainer, "Expected Mozilla child widget");
+// We skip the nsWindows that don't have mGdkWindows.
+// These are probably in the process of being destroyed.
+if (!GetNextSibling()) {
+// We're to be on top.
+if (mGdkWindow)
+gdk_window_raise(mGdkWindow);
+} else {
+// All the siblings before us need to be below our widget.
+for (nsWindow* w = this; w;
+w = static_cast<nsWindow*>(w->GetPrevSibling())) {
+if (w->mGdkWindow)
+gdk_window_lower(w->mGdkWindow);
+}
+}
+}
+NS_IMETHODIMP
+nsWindow::SetSizeMode(int32_t aMode)
+{
+nsresult rv;
+LOG(("nsWindow::SetSizeMode [%p] %d\n", (void *)this, aMode));
+// Save the requested state.
+rv = nsBaseWidget::SetSizeMode(aMode);
+// return if there's no shell or our current state is the same as
+// the mode we were just set to.
+if (!mShell || mSizeState == mSizeMode) {
+return rv;
+}
+switch (aMode) {
+case nsSizeMode_Maximized:
+gtk_window_maximize(GTK_WINDOW(mShell));
+break;
+case nsSizeMode_Minimized:
+gtk_window_iconify(GTK_WINDOW(mShell));
+break;
+case nsSizeMode_Fullscreen:
+MakeFullScreen(true);
+break;
+default:
+// nsSizeMode_Normal, really.
+if (mSizeState == nsSizeMode_Minimized)
+gtk_window_deiconify(GTK_WINDOW(mShell));
+else if (mSizeState == nsSizeMode_Maximized)
+gtk_window_unmaximize(GTK_WINDOW(mShell));
+break;
+}
+mSizeState = mSizeMode;
+return rv;
+}
+typedef void (* SetUserTimeFunc)(GdkWindow* aWindow, guint32 aTimestamp);
+// This will become obsolete when new GTK APIs are widely supported,
+// as described here: http://bugzilla.gnome.org/show_bug.cgi?id=347375
+static void
+SetUserTimeAndStartupIDForActivatedWindow(GtkWidget* aWindow)
+{
+nsGTKToolkit* GTKToolkit = nsGTKToolkit::GetToolkit();
+if (!GTKToolkit)
+return;
+nsAutoCString desktopStartupID;
+GTKToolkit->GetDesktopStartupID(&desktopStartupID);
+if (desktopStartupID.IsEmpty()) {
+// We don't have the data we need. Fall back to an
+// approximation ... using the timestamp of the remote command
+// being received as a guess for the timestamp of the user event
+// that triggered it.
+uint32_t timestamp = GTKToolkit->GetFocusTimestamp();
+if (timestamp) {
+gdk_window_focus(gtk_widget_get_window(aWindow), timestamp);
+GTKToolkit->SetFocusTimestamp(0);
+}
+return;
+}
+#if defined(MOZ_ENABLE_STARTUP_NOTIFICATION)
+GdkWindow* gdkWindow = gtk_widget_get_window(aWindow);
+GdkScreen* screen = gdk_window_get_screen(gdkWindow);
+SnDisplay* snd =
+sn_display_new(gdk_x11_display_get_xdisplay(gdk_window_get_display(gdkWindow)),
+nullptr, nullptr);
+if (!snd)
+return;
+SnLauncheeContext* ctx =
+sn_launchee_context_new(snd, gdk_screen_get_number(screen),
+desktopStartupID.get());
+if (!ctx) {
+sn_display_unref(snd);
+return;
+}
+if (sn_launchee_context_get_id_has_timestamp(ctx)) {
+PRLibrary* gtkLibrary;
+SetUserTimeFunc setUserTimeFunc = (SetUserTimeFunc)
+PR_FindFunctionSymbolAndLibrary("gdk_x11_window_set_user_time", &gtkLibrary);
+if (setUserTimeFunc) {
+setUserTimeFunc(gdkWindow, sn_launchee_context_get_timestamp(ctx));
+PR_UnloadLibrary(gtkLibrary);
+}
+}
+sn_launchee_context_setup_window(ctx, gdk_x11_window_get_xid(gdkWindow));
+sn_launchee_context_complete(ctx);
+sn_launchee_context_unref(ctx);
+sn_display_unref(snd);
+#endif
+// If we used the startup ID, that already contains the focus timestamp;
+// we don't want to reuse the timestamp next time we raise the window
+GTKToolkit->SetFocusTimestamp(0);
+GTKToolkit->SetDesktopStartupID(EmptyCString());
+}
+/* static */ guint32
+nsWindow::GetLastUserInputTime()
+{
+// gdk_x11_display_get_user_time tracks button and key presses,
+// DESKTOP_STARTUP_ID used to start the app, drop events from external
+// drags, WM_DELETE_WINDOW delete events, but not usually mouse motion nor
+// button and key releases.  Therefore use the most recent of
+// gdk_x11_display_get_user_time and the last time that we have seen.
+guint32 timestamp =
+gdk_x11_display_get_user_time(gdk_display_get_default());
+if (sLastUserInputTime != GDK_CURRENT_TIME &&
+TimestampIsNewerThan(sLastUserInputTime, timestamp)) {
+return sLastUserInputTime;
+}
+return timestamp;
+}
+NS_IMETHODIMP
+nsWindow::SetFocus(bool aRaise)
+{
+// Make sure that our owning widget has focus.  If it doesn't try to
+// grab it.  Note that we don't set our focus flag in this case.
+LOGFOCUS(("  SetFocus %d [%p]\n", aRaise, (void *)this));
+GtkWidget *owningWidget = GetMozContainerWidget();
+if (!owningWidget)
+return NS_ERROR_FAILURE;
+// Raise the window if someone passed in true and the prefs are
+// set properly.
+GtkWidget *toplevelWidget = gtk_widget_get_toplevel(owningWidget);
+if (gRaiseWindows && aRaise && toplevelWidget &&
+!gtk_widget_has_focus(owningWidget) &&
+!gtk_widget_has_focus(toplevelWidget)) {
+GtkWidget* top_window = GetToplevelWidget();
+if (top_window && (gtk_widget_get_visible(top_window)))
+{
+gdk_window_show_unraised(gtk_widget_get_window(top_window));
+// Unset the urgency hint if possible.
+SetUrgencyHint(top_window, false);
+}
+}
+nsRefPtr<nsWindow> owningWindow = get_window_for_gtk_widget(owningWidget);
+if (!owningWindow)
+return NS_ERROR_FAILURE;
+if (aRaise) {
+// aRaise == true means request toplevel activation.
+// This is asynchronous.
+// If and when the window manager accepts the request, then the focus
+// widget will get a focus-in-event signal.
+if (gRaiseWindows && owningWindow->mIsShown && owningWindow->mShell &&
+!gtk_window_is_active(GTK_WINDOW(owningWindow->mShell))) {
+uint32_t timestamp = GDK_CURRENT_TIME;
+nsGTKToolkit* GTKToolkit = nsGTKToolkit::GetToolkit();
+if (GTKToolkit)
+timestamp = GTKToolkit->GetFocusTimestamp();
+LOGFOCUS(("  requesting toplevel activation [%p]\n", (void *)this));
+NS_ASSERTION(owningWindow->mWindowType != eWindowType_popup
+|| mParent,
+"Presenting an override-redirect window");
+gtk_window_present_with_time(GTK_WINDOW(owningWindow->mShell), timestamp);
+if (GTKToolkit)
+GTKToolkit->SetFocusTimestamp(0);
+}
+return NS_OK;
+}
+// aRaise == false means that keyboard events should be dispatched
+// from this widget.
+// Ensure owningWidget is the focused GtkWidget within its toplevel window.
+//
+// For eWindowType_popup, this GtkWidget may not actually be the one that
+// receives the key events as it may be the parent window that is active.
+if (!gtk_widget_is_focus(owningWidget)) {
+// This is synchronous.  It takes focus from a plugin or from a widget
+// in an embedder.  The focus manager already knows that this window
+// is active so gBlockActivateEvent avoids another (unnecessary)
+// activate notification.
+gBlockActivateEvent = true;
+gtk_widget_grab_focus(owningWidget);
+gBlockActivateEvent = false;
+}
+// If this is the widget that already has focus, return.
+if (gFocusWindow == this) {
+LOGFOCUS(("  already have focus [%p]\n", (void *)this));
+return NS_OK;
+}
+// Set this window to be the focused child window
+gFocusWindow = this;
+if (mIMModule) {
+mIMModule->OnFocusWindow(this);
+}
+LOGFOCUS(("  widget now has focus in SetFocus() [%p]\n",
+(void *)this));
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::GetScreenBounds(nsIntRect &aRect)
+{
+if (mIsTopLevel && mContainer) {
+// use the point including window decorations
+gint x, y;
+gdk_window_get_root_origin(gtk_widget_get_window(GTK_WIDGET(mContainer)), &x, &y);
+aRect.MoveTo(x, y);
+}
+else {
+aRect.MoveTo(WidgetToScreenOffset());
+}
+// mBounds.Size() is the window bounds, not the window-manager frame
+// bounds (bug 581863).  gdk_window_get_frame_extents would give the
+// frame bounds, but mBounds.Size() is returned here for consistency
+// with Resize.
+aRect.SizeTo(mBounds.Size());
+LOG(("GetScreenBounds %d,%d | %dx%d\n",
+aRect.x, aRect.y, aRect.width, aRect.height));
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::GetClientBounds(nsIntRect &aRect)
+{
+// GetBounds returns a rect whose top left represents the top left of the
+// outer bounds, but whose width/height represent the size of the inner
+// bounds (which is messed up).
+GetBounds(aRect);
+aRect.MoveBy(GetClientOffset());
+return NS_OK;
+}
+nsIntPoint
+nsWindow::GetClientOffset()
+{
+if (!mIsTopLevel) {
+return nsIntPoint(0, 0);
+}
+GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
+GdkAtom type_returned;
+int format_returned;
+int length_returned;
+long *frame_extents;
+GdkWindow* window;
+if (!mShell || !(window = gtk_widget_get_window(mShell)) ||
+!gdk_property_get(window,
+gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE),
+cardinal_atom,
+0, // offset
+4*4, // length
+FALSE, // delete
+&type_returned,
+&format_returned,
+&length_returned,
+(guchar **) &frame_extents) ||
+length_returned/sizeof(glong) != 4) {
+return nsIntPoint(0, 0);
+}
+// data returned is in the order left, right, top, bottom
+int32_t left = int32_t(frame_extents[0]);
+int32_t top = int32_t(frame_extents[2]);
+g_free(frame_extents);
+return nsIntPoint(left, top);
+}
+NS_IMETHODIMP
+nsWindow::SetCursor(nsCursor aCursor)
+{
+// if we're not the toplevel window pass up the cursor request to
+// the toplevel window to handle it.
+if (!mContainer && mGdkWindow) {
+nsWindow *window = GetContainerWindow();
+if (!window)
+return NS_ERROR_FAILURE;
+return window->SetCursor(aCursor);
+}
+// Only change cursor if it's actually been changed
+if (aCursor != mCursor) {
+GdkCursor *newCursor = nullptr;
+newCursor = get_gtk_cursor(aCursor);
+if (nullptr != newCursor) {
+mCursor = aCursor;
+if (!mContainer)
+return NS_OK;
+gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(mContainer)), newCursor);
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::SetCursor(imgIContainer* aCursor,
+uint32_t aHotspotX, uint32_t aHotspotY)
+{
+// if we're not the toplevel window pass up the cursor request to
+// the toplevel window to handle it.
+if (!mContainer && mGdkWindow) {
+nsWindow *window = GetContainerWindow();
+if (!window)
+return NS_ERROR_FAILURE;
+return window->SetCursor(aCursor, aHotspotX, aHotspotY);
+}
+mCursor = nsCursor(-1);
+// Get the image's current frame
+GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(aCursor);
+if (!pixbuf)
+return NS_ERROR_NOT_AVAILABLE;
+int width = gdk_pixbuf_get_width(pixbuf);
+int height = gdk_pixbuf_get_height(pixbuf);
+// Reject cursors greater than 128 pixels in some direction, to prevent
+// spoofing.
+// XXX ideally we should rescale. Also, we could modify the API to
+// allow trusted content to set larger cursors.
+if (width > 128 || height > 128) {
+g_object_unref(pixbuf);
+return NS_ERROR_NOT_AVAILABLE;
+}
+// Looks like all cursors need an alpha channel (tested on Gtk 2.4.4). This
+// is of course not documented anywhere...
+// So add one if there isn't one yet
+if (!gdk_pixbuf_get_has_alpha(pixbuf)) {
+GdkPixbuf* alphaBuf = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
+g_object_unref(pixbuf);
+if (!alphaBuf) {
+return NS_ERROR_OUT_OF_MEMORY;
+}
+pixbuf = alphaBuf;
+}
+GdkCursor* cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(),
+pixbuf,
+aHotspotX, aHotspotY);
+g_object_unref(pixbuf);
+nsresult rv = NS_ERROR_OUT_OF_MEMORY;
+if (cursor) {
+if (mContainer) {
+gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(mContainer)), cursor);
+rv = NS_OK;
+}
+gdk_cursor_unref(cursor);
+}
+return rv;
+}
+NS_IMETHODIMP
+nsWindow::Invalidate(const nsIntRect &aRect)
+{
+if (!mGdkWindow)
+return NS_OK;
+GdkRectangle rect;
+rect.x = aRect.x;
+rect.y = aRect.y;
+rect.width = aRect.width;
+rect.height = aRect.height;
+LOGDRAW(("Invalidate (rect) [%p]: %d %d %d %d\n", (void *)this,
+rect.x, rect.y, rect.width, rect.height));
+gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
+return NS_OK;
+}
+void*
+nsWindow::GetNativeData(uint32_t aDataType)
+{
+switch (aDataType) {
+case NS_NATIVE_WINDOW:
+case NS_NATIVE_WIDGET: {
+if (!mGdkWindow)
+return nullptr;
+return mGdkWindow;
+break;
+}
+case NS_NATIVE_PLUGIN_PORT:
+return SetupPluginPort();
+break;
+case NS_NATIVE_DISPLAY:
+#ifdef MOZ_X11
+return GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+#else
+return nullptr;
+#endif /* MOZ_X11 */
+break;
+case NS_NATIVE_SHELLWIDGET:
+return GetToplevelWidget();
+case NS_NATIVE_SHAREABLE_WINDOW:
+return (void *) GDK_WINDOW_XID(gdk_window_get_toplevel(mGdkWindow));
+default:
+NS_WARNING("nsWindow::GetNativeData called with bad value");
+return nullptr;
+}
+}
+NS_IMETHODIMP
+nsWindow::SetTitle(const nsAString& aTitle)
+{
+if (!mShell)
+return NS_OK;
+// convert the string into utf8 and set the title.
+#define UTF8_FOLLOWBYTE(ch) (((ch) & 0xC0) == 0x80)
+NS_ConvertUTF16toUTF8 titleUTF8(aTitle);
+if (titleUTF8.Length() > NS_WINDOW_TITLE_MAX_LENGTH) {
+// Truncate overlong titles (bug 167315). Make sure we chop after a
+// complete sequence by making sure the next char isn't a follow-byte.
+uint32_t len = NS_WINDOW_TITLE_MAX_LENGTH;
+while(UTF8_FOLLOWBYTE(titleUTF8[len]))
+--len;
+titleUTF8.Truncate(len);
+}
+gtk_window_set_title(GTK_WINDOW(mShell), (const char *)titleUTF8.get());
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::SetIcon(const nsAString& aIconSpec)
+{
+if (!mShell)
+return NS_OK;
+nsAutoCString iconName;
+if (aIconSpec.EqualsLiteral("default")) {
+nsXPIDLString brandName;
+GetBrandName(brandName);
+AppendUTF16toUTF8(brandName, iconName);
+ToLowerCase(iconName);
+} else {
+AppendUTF16toUTF8(aIconSpec, iconName);
+}
+nsCOMPtr<nsIFile> iconFile;
+nsAutoCString path;
+gint *iconSizes =
+gtk_icon_theme_get_icon_sizes(gtk_icon_theme_get_default(),
+iconName.get());
+bool foundIcon = (iconSizes[0] != 0);
+g_free(iconSizes);
+if (!foundIcon) {
+// Look for icons with the following suffixes appended to the base name
+// The last two entries (for the old XPM format) will be ignored unless
+// no icons are found using other suffixes. XPM icons are deprecated.
+const char extensions[6][7] = { ".png", "16.png", "32.png", "48.png",
+".xpm", "16.xpm" };
+for (uint32_t i = 0; i < ArrayLength(extensions); i++) {
+// Don't bother looking for XPM versions if we found a PNG.
+if (i == ArrayLength(extensions) - 2 && foundIcon)
+break;
+nsAutoString extension;
+extension.AppendASCII(extensions[i]);
+ResolveIconName(aIconSpec, extension, getter_AddRefs(iconFile));
+if (iconFile) {
+iconFile->GetNativePath(path);
+GdkPixbuf *icon = gdk_pixbuf_new_from_file(path.get(), nullptr);
+if (icon) {
+gtk_icon_theme_add_builtin_icon(iconName.get(),
+gdk_pixbuf_get_height(icon),
+icon);
+g_object_unref(icon);
+foundIcon = true;
+}
+}
+}
+}
+// leave the default icon intact if no matching icons were found
+if (foundIcon) {
+gtk_window_set_icon_name(GTK_WINDOW(mShell), iconName.get());
+}
+return NS_OK;
+}
+nsIntPoint
+nsWindow::WidgetToScreenOffset()
+{
+gint x = 0, y = 0;
+if (mGdkWindow) {
+gdk_window_get_origin(mGdkWindow, &x, &y);
+}
+return nsIntPoint(x, y);
+}
+NS_IMETHODIMP
+nsWindow::EnableDragDrop(bool aEnable)
+{
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::CaptureMouse(bool aCapture)
+{
+LOG(("CaptureMouse %p\n", (void *)this));
+if (!mGdkWindow)
+return NS_OK;
+if (!mShell)
+return NS_ERROR_FAILURE;
+if (aCapture) {
+gtk_grab_add(mShell);
+GrabPointer(GetLastUserInputTime());
+}
+else {
+ReleaseGrabs();
+gtk_grab_remove(mShell);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::CaptureRollupEvents(nsIRollupListener *aListener,
+bool               aDoCapture)
+{
+if (!mGdkWindow)
+return NS_OK;
+if (!mShell)
+return NS_ERROR_FAILURE;
+LOG(("CaptureRollupEvents %p %i\n", this, int(aDoCapture)));
+if (aDoCapture) {
+gRollupListener = aListener;
+// real grab is only done when there is no dragging
+if (!nsWindow::DragInProgress()) {
+// This widget grab ensures that a Gecko GtkWidget receives mouse
+// events even when embedded in non-Gecko-owned GtkWidgets.
+// The grab is placed on the toplevel GtkWindow instead of the
+// MozContainer to avoid double dispatch of keyboard events
+// (bug 707623).
+gtk_grab_add(mShell);
+GrabPointer(GetLastUserInputTime());
+}
+}
+else {
+if (!nsWindow::DragInProgress()) {
+ReleaseGrabs();
+}
+// There may not have been a drag in process when aDoCapture was set,
+// so make sure to remove any added grab.  This is a no-op if the grab
+// was not added to this widget.
+gtk_grab_remove(mShell);
+gRollupListener = nullptr;
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::GetAttention(int32_t aCycleCount)
+{
+LOG(("nsWindow::GetAttention [%p]\n", (void *)this));
+GtkWidget* top_window = GetToplevelWidget();
+GtkWidget* top_focused_window =
+gFocusWindow ? gFocusWindow->GetToplevelWidget() : nullptr;
+// Don't get attention if the window is focused anyway.
+if (top_window && (gtk_widget_get_visible(top_window)) &&
+top_window != top_focused_window) {
+SetUrgencyHint(top_window, true);
+}
+return NS_OK;
+}
+bool
+nsWindow::HasPendingInputEvent()
+{
+// This sucks, but gtk/gdk has no way to answer the question we want while
+// excluding paint events, and there's no X API that will let us peek
+// without blocking or removing.  To prevent event reordering, peek
+// anything except expose events.  Reordering expose and others should be
+// ok, hopefully.
+bool haveEvent;
+#ifdef MOZ_X11
+XEvent ev;
+Display *display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+haveEvent =
+XCheckMaskEvent(display,
+KeyPressMask | KeyReleaseMask | ButtonPressMask |
+ButtonReleaseMask | EnterWindowMask | LeaveWindowMask |
+PointerMotionMask | PointerMotionHintMask |
+Button1MotionMask | Button2MotionMask |
+Button3MotionMask | Button4MotionMask |
+Button5MotionMask | ButtonMotionMask | KeymapStateMask |
+VisibilityChangeMask | StructureNotifyMask |
+ResizeRedirectMask | SubstructureNotifyMask |
+SubstructureRedirectMask | FocusChangeMask |
+PropertyChangeMask | ColormapChangeMask |
+OwnerGrabButtonMask, &ev);
+if (haveEvent) {
+XPutBackEvent(display, &ev);
+}
+#else
+haveEvent = false;
+#endif
+return haveEvent;
+}
+#if 0
+#ifdef DEBUG
+// Paint flashing code (disabled for cairo - see below)
+#define CAPS_LOCK_IS_ON \
+(KeymapWrapper::AreModifiersCurrentlyActive(KeymapWrapper::CAPS_LOCK))
+#define WANT_PAINT_FLASHING \
+(debug_WantPaintFlashing() && CAPS_LOCK_IS_ON)
+#ifdef MOZ_X11
+static void
+gdk_window_flash(GdkWindow *    aGdkWindow,
+unsigned int   aTimes,
+unsigned int   aInterval,  // Milliseconds
+GdkRegion *    aRegion)
+{
+gint         x;
+gint         y;
+gint         width;
+gint         height;
+guint        i;
+GdkGC *      gc = 0;
+GdkColor     white;
+#if (MOZ_WIDGET_GTK == 2)
+gdk_window_get_geometry(aGdkWindow,nullptr,nullptr,&width,&height,nullptr);
+#else
+gdk_window_get_geometry(aGdkWindow,nullptr,nullptr,&width,&height);
+#endif
+gdk_window_get_origin (aGdkWindow,
+&x,
+&y);
+gc = gdk_gc_new(gdk_get_default_root_window());
+white.pixel = WhitePixel(gdk_display,DefaultScreen(gdk_display));
+gdk_gc_set_foreground(gc,&white);
+gdk_gc_set_function(gc,GDK_XOR);
+gdk_gc_set_subwindow(gc,GDK_INCLUDE_INFERIORS);
+gdk_region_offset(aRegion, x, y);
+gdk_gc_set_clip_region(gc, aRegion);
+/*
+* Need to do this twice so that the XOR effect can replace
+* the original window contents.
+*/
+for (i = 0; i < aTimes * 2; i++)
+{
+gdk_draw_rectangle(gdk_get_default_root_window(),
+gc,
+TRUE,
+x,
+y,
+width,
+height);
+gdk_flush();
+PR_Sleep(PR_MillisecondsToInterval(aInterval));
+}
+gdk_gc_destroy(gc);
+gdk_region_offset(aRegion, -x, -y);
+}
+#endif /* MOZ_X11 */
+#endif // DEBUG
+#endif
+struct ExposeRegion
+{
+nsIntRegion mRegion;
+#if (MOZ_WIDGET_GTK == 2)
+GdkRectangle *mRects;
+GdkRectangle *mRectsEnd;
+ExposeRegion() : mRects(nullptr)
+{
+}
+~ExposeRegion()
+{
+g_free(mRects);
+}
+bool Init(GdkEventExpose *aEvent)
+{
+gint nrects;
+gdk_region_get_rectangles(aEvent->region, &mRects, &nrects);
+if (nrects > MAX_RECTS_IN_REGION) {
+// Just use the bounding box
+mRects[0] = aEvent->area;
+nrects = 1;
+}
+mRectsEnd = mRects + nrects;
+for (GdkRectangle *r = mRects; r < mRectsEnd; r++) {
+mRegion.Or(mRegion, nsIntRect(r->x, r->y, r->width, r->height));
+LOGDRAW(("\t%d %d %d %d\n", r->x, r->y, r->width, r->height));
+}
+return true;
+}
+#else
+# ifdef cairo_copy_clip_rectangle_list
+#  error "Looks like we're including Mozilla's cairo instead of system cairo"
+# endif
+cairo_rectangle_list_t *mRects;
+ExposeRegion() : mRects(nullptr)
+{
+}
+~ExposeRegion()
+{
+cairo_rectangle_list_destroy(mRects);
+}
+bool Init(cairo_t* cr)
+{
+mRects = cairo_copy_clip_rectangle_list(cr);
+if (mRects->status != CAIRO_STATUS_SUCCESS) {
+NS_WARNING("Failed to obtain cairo rectangle list.");
+return false;
+}
+for (int i = 0; i < mRects->num_rectangles; i++)  {
+const cairo_rectangle_t& r = mRects->rectangles[i];
+mRegion.Or(mRegion, nsIntRect(r.x, r.y, r.width, r.height));
+LOGDRAW(("\t%d %d %d %d\n", r.x, r.y, r.width, r.height));
+}
+return true;
+}
+#endif
+};
+#if (MOZ_WIDGET_GTK == 2)
+gboolean
+nsWindow::OnExposeEvent(GdkEventExpose *aEvent)
+#else
+gboolean
+nsWindow::OnExposeEvent(cairo_t *cr)
+#endif
+{
+if (mIsDestroyed) {
+return FALSE;
+}
+// Windows that are not visible will be painted after they become visible.
+if (!mGdkWindow || mIsFullyObscured || !mHasMappedToplevel)
+return FALSE;
+nsIWidgetListener *listener =
+mAttachedWidgetListener ? mAttachedWidgetListener : mWidgetListener;
+if (!listener)
+return FALSE;
+ExposeRegion exposeRegion;
+#if (MOZ_WIDGET_GTK == 2)
+if (!exposeRegion.Init(aEvent)) {
+#else
+if (!exposeRegion.Init(cr)) {
+#endif
+return FALSE;
+}
+nsIntRegion &region = exposeRegion.mRegion;
+ClientLayerManager *clientLayers =
+(GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_CLIENT)
+? static_cast<ClientLayerManager*>(GetLayerManager())
+: nullptr;
+if (clientLayers && mCompositorParent) {
+// We need to paint to the screen even if nothing changed, since if we
+// don't have a compositing window manager, our pixels could be stale.
+clientLayers->SetNeedsComposite(true);
+clientLayers->SendInvalidRegion(region);
+}
+// Dispatch WillPaintWindow notification to allow scripts etc. to run
+// before we paint
+{
+listener->WillPaintWindow(this);
+// If the window has been destroyed during the will paint notification,
+// there is nothing left to do.
+if (!mGdkWindow)
+return TRUE;
+// Re-get the listener since the will paint notification might have
+// killed it.
+listener =
+mAttachedWidgetListener ? mAttachedWidgetListener : mWidgetListener;
+if (!listener)
+return FALSE;
+}
+if (clientLayers && mCompositorParent && clientLayers->NeedsComposite()) {
+mCompositorParent->ScheduleRenderOnCompositorThread();
+clientLayers->SetNeedsComposite(false);
+}
+LOGDRAW(("sending expose event [%p] %p 0x%lx (rects follow):\n",
+(void *)this, (void *)mGdkWindow,
+gdk_x11_window_get_xid(mGdkWindow)));
+// Our bounds may have changed after calling WillPaintWindow.  Clip
+// to the new bounds here.  The region is relative to this
+// window.
+region.And(region, nsIntRect(0, 0, mBounds.width, mBounds.height));
+bool shaped = false;
+if (eTransparencyTransparent == GetTransparencyMode()) {
+GdkScreen *screen = gdk_window_get_screen(mGdkWindow);
+if (gdk_screen_is_composited(screen) &&
+gdk_window_get_visual(mGdkWindow) ==
+gdk_screen_get_rgba_visual(screen)) {
+// Remove possible shape mask from when window manger was not
+// previously compositing.
+static_cast<nsWindow*>(GetTopLevelWidget())->
+ClearTransparencyBitmap();
+} else {
+shaped = true;
+}
+}
+if (!shaped) {
+GList *children =
+gdk_window_peek_children(mGdkWindow);
+while (children) {
+GdkWindow *gdkWin = GDK_WINDOW(children->data);
+nsWindow *kid = get_window_for_gdk_window(gdkWin);
+if (kid && gdk_window_is_visible(gdkWin)) {
+nsAutoTArray<nsIntRect,1> clipRects;
+kid->GetWindowClipRegion(&clipRects);
+nsIntRect bounds;
+kid->GetBounds(bounds);
+for (uint32_t i = 0; i < clipRects.Length(); ++i) {
+nsIntRect r = clipRects[i] + bounds.TopLeft();
+region.Sub(region, r);
+}
+}
+children = children->next;
+}
+}
+if (region.IsEmpty()) {
+return TRUE;
+}
+// If this widget uses OMTC...
+if (GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_CLIENT) {
+listener->PaintWindow(this, region);
+listener->DidPaintWindow();
+return TRUE;
+}
+gfxASurface* surf;
+#if (MOZ_WIDGET_GTK == 2)
+surf = GetThebesSurface();
+#else
+surf = GetThebesSurface(cr);
+#endif
+nsRefPtr<gfxContext> ctx;
+if (gfxPlatform::GetPlatform()->
+SupportsAzureContentForType(BackendType::CAIRO)) {
+IntSize intSize(surf->GetSize().width, surf->GetSize().height);
+ctx = new gfxContext(gfxPlatform::GetPlatform()->
+CreateDrawTargetForSurface(surf, intSize));
+} else if (gfxPlatform::GetPlatform()->
+SupportsAzureContentForType(BackendType::SKIA) &&
+surf->GetType() == gfxSurfaceType::Image) {
+gfxImageSurface* imgSurf = static_cast<gfxImageSurface*>(surf);
+SurfaceFormat format = ImageFormatToSurfaceFormat(imgSurf->Format());
+IntSize intSize(surf->GetSize().width, surf->GetSize().height);
+ctx = new gfxContext(gfxPlatform::GetPlatform()->CreateDrawTargetForData(
+imgSurf->Data(), intSize, imgSurf->Stride(), format));
+}  else {
+ctx = new gfxContext(surf);
+}
+#ifdef MOZ_X11
+nsIntRect boundsRect; // for shaped only
+ctx->NewPath();
+if (shaped) {
+// Collapse update area to the bounding box. This is so we only have to
+// call UpdateTranslucentWindowAlpha once. After we have dropped
+// support for non-Thebes graphics, UpdateTranslucentWindowAlpha will be
+// our private interface so we can rework things to avoid this.
+boundsRect = region.GetBounds();
+ctx->Rectangle(gfxRect(boundsRect.x, boundsRect.y,
+boundsRect.width, boundsRect.height));
+} else {
+gfxUtils::PathFromRegion(ctx, region);
+}
+ctx->Clip();
+BufferMode layerBuffering;
+if (shaped) {
+// The double buffering is done here to extract the shape mask.
+// (The shape mask won't be necessary when a visual with an alpha
+// channel is used on compositing window managers.)
+layerBuffering = mozilla::layers::BufferMode::BUFFER_NONE;
+ctx->PushGroup(gfxContentType::COLOR_ALPHA);
+#ifdef MOZ_HAVE_SHMIMAGE
+} else if (nsShmImage::UseShm()) {
+// We're using an xshm mapping as a back buffer.
+layerBuffering = mozilla::layers::BufferMode::BUFFER_NONE;
+#endif // MOZ_HAVE_SHMIMAGE
+} else {
+// Get the layer manager to do double buffering (if necessary).
+layerBuffering = mozilla::layers::BufferMode::BUFFERED;
+}
+#if 0
+// NOTE: Paint flashing region would be wrong for cairo, since
+// cairo inflates the update region, etc.  So don't paint flash
+// for cairo.
+#ifdef DEBUG
+// XXX aEvent->region may refer to a newly-invalid area.  FIXME
+if (0 && WANT_PAINT_FLASHING && gtk_widget_get_window(aEvent))
+gdk_window_flash(mGdkWindow, 1, 100, aEvent->region);
+#endif
+#endif
+#endif // MOZ_X11
+bool painted = false;
+{
+if (GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_BASIC) {
+AutoLayerManagerSetup setupLayerManager(this, ctx, layerBuffering);
+painted = listener->PaintWindow(this, region);
+}
+}
+#ifdef MOZ_X11
+// PaintWindow can Destroy us (bug 378273), avoid doing any paint
+// operations below if that happened - it will lead to XError and exit().
+if (shaped) {
+if (MOZ_LIKELY(!mIsDestroyed)) {
+if (painted) {
+nsRefPtr<gfxPattern> pattern = ctx->PopGroup();
+UpdateAlpha(pattern, boundsRect);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->SetPattern(pattern);
+ctx->Paint();
+}
+}
+}
+#  ifdef MOZ_HAVE_SHMIMAGE
+if (mShmImage && MOZ_LIKELY(!mIsDestroyed)) {
+#if (MOZ_WIDGET_GTK == 2)
+mShmImage->Put(mGdkWindow, exposeRegion.mRects, exposeRegion.mRectsEnd);
+#else
+mShmImage->Put(mGdkWindow, exposeRegion.mRects);
+#endif
+}
+#  endif  // MOZ_HAVE_SHMIMAGE
+#endif // MOZ_X11
+listener->DidPaintWindow();
+// Synchronously flush any new dirty areas
+#if (MOZ_WIDGET_GTK == 2)
+GdkRegion* dirtyArea = gdk_window_get_update_area(mGdkWindow);
+#else
+cairo_region_t* dirtyArea = gdk_window_get_update_area(mGdkWindow);
+#endif
+if (dirtyArea) {
+gdk_window_invalidate_region(mGdkWindow, dirtyArea, false);
+#if (MOZ_WIDGET_GTK == 2)
+gdk_region_destroy(dirtyArea);
+#else
+cairo_region_destroy(dirtyArea);
+#endif
+gdk_window_process_updates(mGdkWindow, false);
+}
+// check the return value!
+return TRUE;
+}
+void
+nsWindow::UpdateAlpha(gfxPattern* aPattern, nsIntRect aBoundsRect)
+{
+// We need to create our own buffer to force the stride to match the
+// expected stride.
+int32_t stride = GetAlignedStride<4>(BytesPerPixel(SurfaceFormat::A8) *
+aBoundsRect.width);
+int32_t bufferSize = stride * aBoundsRect.height;
+nsAutoArrayPtr<uint8_t> imageBuffer(new (std::nothrow) uint8_t[bufferSize]);
+RefPtr<DrawTarget> drawTarget = gfxPlatform::GetPlatform()->
+CreateDrawTargetForData(imageBuffer, ToIntSize(aBoundsRect.Size()),
+stride, SurfaceFormat::A8);
+if (drawTarget) {
+drawTarget->FillRect(Rect(0, 0, aBoundsRect.width, aBoundsRect.height),
+*aPattern->GetPattern(drawTarget),
+DrawOptions(1.0, CompositionOp::OP_SOURCE));
+}
+UpdateTranslucentWindowAlphaInternal(aBoundsRect, imageBuffer, stride);
+}
+gboolean
+nsWindow::OnConfigureEvent(GtkWidget *aWidget, GdkEventConfigure *aEvent)
+{
+// These events are only received on toplevel windows.
+//
+// GDK ensures that the coordinates are the client window top-left wrt the
+// root window.
+//
+//   GDK calculates the cordinates for real ConfigureNotify events on
+//   managed windows (that would normally be relative to the parent
+//   window).
+//
+//   Synthetic ConfigureNotify events are from the window manager and
+//   already relative to the root window.  GDK creates all X windows with
+//   border_width = 0, so synthetic events also indicate the top-left of
+//   the client window.
+//
+//   Override-redirect windows are children of the root window so parent
+//   coordinates are root coordinates.
+LOG(("configure event [%p] %d %d %d %d\n", (void *)this,
+aEvent->x, aEvent->y, aEvent->width, aEvent->height));
+nsIntRect screenBounds;
+GetScreenBounds(screenBounds);
+if (mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog) {
+// This check avoids unwanted rollup on spurious configure events from
+// Cygwin/X (bug 672103).
+if (mBounds.x != screenBounds.x ||
+mBounds.y != screenBounds.y) {
+CheckForRollup(0, 0, false, true);
+}
+}
+// This event indicates that the window position may have changed.
+// mBounds.Size() is updated in OnSizeAllocate().
+// (The gtk_window_get_window_type() function is only available from
+// version 2.20.)
+NS_ASSERTION(GTK_IS_WINDOW(aWidget),
+"Configure event on widget that is not a GtkWindow");
+gint type;
+g_object_get(aWidget, "type", &type, nullptr);
+if (type == GTK_WINDOW_POPUP) {
+// Override-redirect window
+//
+// These windows should not be moved by the window manager, and so any
+// change in position is a result of our direction.  mBounds has
+// already been set in Move() or Resize(), and that is more
+// up-to-date than the position in the ConfigureNotify event if the
+// event is from an earlier window move.
+//
+// Skipping the WindowMoved call saves context menus from an infinite
+// loop when nsXULPopupManager::PopupMoved moves the window to the new
+// position and nsMenuPopupFrame::SetPopupPosition adds
+// offsetForContextMenu on each iteration.
+return FALSE;
+}
+mBounds.MoveTo(screenBounds.TopLeft());
+// XXX mozilla will invalidate the entire window after this move
+// complete.  wtf?
+NotifyWindowMoved(mBounds.x, mBounds.y);
+return FALSE;
+}
+void
+nsWindow::OnContainerUnrealize()
+{
+// The GdkWindows are about to be destroyed (but not deleted), so remove
+// their references back to their container widget while the GdkWindow
+// hierarchy is still available.
+if (mGdkWindow) {
+DestroyChildWindows();
+g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", nullptr);
+mGdkWindow = nullptr;
+}
+}
+void
+nsWindow::OnSizeAllocate(GtkAllocation *aAllocation)
+{
+LOG(("size_allocate [%p] %d %d %d %d\n",
+(void *)this, aAllocation->x, aAllocation->y,
+aAllocation->width, aAllocation->height));
+nsIntSize size(aAllocation->width, aAllocation->height);
+if (mBounds.Size() == size)
+return;
+// Invalidate the new part of the window now for the pending paint to
+// minimize background flashes (GDK does not do this for external resizes
+// of toplevels.)
+if (mBounds.width < size.width) {
+GdkRectangle rect =
+{ mBounds.width, 0, size.width - mBounds.width, size.height };
+gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
+}
+if (mBounds.height < size.height) {
+GdkRectangle rect =
+{ 0, mBounds.height, size.width, size.height - mBounds.height };
+gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE);
+}
+mBounds.SizeTo(size);
+if (!mGdkWindow)
+return;
+DispatchResized(size.width, size.height);
+}
+void
+nsWindow::OnDeleteEvent()
+{
+if (mWidgetListener)
+mWidgetListener->RequestWindowClose(this);
+}
+void
+nsWindow::OnEnterNotifyEvent(GdkEventCrossing *aEvent)
+{
+// This skips NotifyVirtual and NotifyNonlinearVirtual enter notify events
+// when the pointer enters a child window.  If the destination window is a
+// Gecko window then we'll catch the corresponding event on that window,
+// but we won't notice when the pointer directly enters a foreign (plugin)
+// child window without passing over a visible portion of a Gecko window.
+if (aEvent->subwindow != nullptr)
+return;
+// Check before is_parent_ungrab_enter() as the button state may have
+// changed while a non-Gecko ancestor window had a pointer grab.
+DispatchMissedButtonReleases(aEvent);
+if (is_parent_ungrab_enter(aEvent))
+return;
+WidgetMouseEvent event(true, NS_MOUSE_ENTER, this, WidgetMouseEvent::eReal);
+event.refPoint.x = nscoord(aEvent->x);
+event.refPoint.y = nscoord(aEvent->y);
+event.time = aEvent->time;
+LOG(("OnEnterNotify: %p\n", (void *)this));
+nsEventStatus status;
+DispatchEvent(&event, status);
+}
+// XXX Is this the right test for embedding cases?
+static bool
+is_top_level_mouse_exit(GdkWindow* aWindow, GdkEventCrossing *aEvent)
+{
+gint x = gint(aEvent->x_root);
+gint y = gint(aEvent->y_root);
+GdkDisplay* display = gdk_window_get_display(aWindow);
+GdkWindow* winAtPt = gdk_display_get_window_at_pointer(display, &x, &y);
+if (!winAtPt)
+return true;
+GdkWindow* topLevelAtPt = gdk_window_get_toplevel(winAtPt);
+GdkWindow* topLevelWidget = gdk_window_get_toplevel(aWindow);
+return topLevelAtPt != topLevelWidget;
+}
+void
+nsWindow::OnLeaveNotifyEvent(GdkEventCrossing *aEvent)
+{
+// This ignores NotifyVirtual and NotifyNonlinearVirtual leave notify
+// events when the pointer leaves a child window.  If the destination
+// window is a Gecko window then we'll catch the corresponding event on
+// that window.
+//
+// XXXkt However, we will miss toplevel exits when the pointer directly
+// leaves a foreign (plugin) child window without passing over a visible
+// portion of a Gecko window.
+if (aEvent->subwindow != nullptr)
+return;
+WidgetMouseEvent event(true, NS_MOUSE_EXIT, this, WidgetMouseEvent::eReal);
+event.refPoint.x = nscoord(aEvent->x);
+event.refPoint.y = nscoord(aEvent->y);
+event.time = aEvent->time;
+event.exit = is_top_level_mouse_exit(mGdkWindow, aEvent)
+? WidgetMouseEvent::eTopLevel : WidgetMouseEvent::eChild;
+LOG(("OnLeaveNotify: %p\n", (void *)this));
+nsEventStatus status;
+DispatchEvent(&event, status);
+}
+void
+nsWindow::OnMotionNotifyEvent(GdkEventMotion *aEvent)
+{
+// see if we can compress this event
+// XXXldb Why skip every other motion event when we have multiple,
+// but not more than that?
+bool synthEvent = false;
+#ifdef MOZ_X11
+XEvent xevent;
+while (XPending (GDK_WINDOW_XDISPLAY(aEvent->window))) {
+XEvent peeked;
+XPeekEvent (GDK_WINDOW_XDISPLAY(aEvent->window), &peeked);
+if (peeked.xany.window != gdk_x11_window_get_xid(aEvent->window)
+|| peeked.type != MotionNotify)
+break;
+synthEvent = true;
+XNextEvent (GDK_WINDOW_XDISPLAY(aEvent->window), &xevent);
+}
+#if (MOZ_WIDGET_GTK == 2)
+// if plugins still keeps the focus, get it back
+if (gPluginFocusWindow && gPluginFocusWindow != this) {
+nsRefPtr<nsWindow> kungFuDeathGrip = gPluginFocusWindow;
+gPluginFocusWindow->LoseNonXEmbedPluginFocus();
+}
+#endif /* MOZ_WIDGET_GTK2 */
+#endif /* MOZ_X11 */
+WidgetMouseEvent event(true, NS_MOUSE_MOVE, this, WidgetMouseEvent::eReal);
+gdouble pressure = 0;
+gdk_event_get_axis ((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure);
+// Sometime gdk generate 0 pressure value between normal values
+// We have to ignore that and use last valid value
+if (pressure)
+mLastMotionPressure = pressure;
+event.pressure = mLastMotionPressure;
+guint modifierState;
+if (synthEvent) {
+#ifdef MOZ_X11
+event.refPoint.x = nscoord(xevent.xmotion.x);
+event.refPoint.y = nscoord(xevent.xmotion.y);
+modifierState = xevent.xmotion.state;
+event.time = xevent.xmotion.time;
+#else
+event.refPoint.x = nscoord(aEvent->x);
+event.refPoint.y = nscoord(aEvent->y);
+modifierState = aEvent->state;
+event.time = aEvent->time;
+#endif /* MOZ_X11 */
+}
+else {
+// XXX see OnScrollEvent()
+if (aEvent->window == mGdkWindow) {
+event.refPoint.x = nscoord(aEvent->x);
+event.refPoint.y = nscoord(aEvent->y);
+} else {
+LayoutDeviceIntPoint point(NSToIntFloor(aEvent->x_root),
+NSToIntFloor(aEvent->y_root));
+event.refPoint = point -
+LayoutDeviceIntPoint::FromUntyped(WidgetToScreenOffset());
+}
+modifierState = aEvent->state;
+event.time = aEvent->time;
+}
+KeymapWrapper::InitInputEvent(event, modifierState);
+nsEventStatus status;
+DispatchEvent(&event, status);
+}
+// If the automatic pointer grab on ButtonPress has deactivated before
+// ButtonRelease, and the mouse button is released while the pointer is not
+// over any a Gecko window, then the ButtonRelease event will not be received.
+// (A similar situation exists when the pointer is grabbed with owner_events
+// True as the ButtonRelease may be received on a foreign [plugin] window).
+// Use this method to check for released buttons when the pointer returns to a
+// Gecko window.
+void
+nsWindow::DispatchMissedButtonReleases(GdkEventCrossing *aGdkEvent)
+{
+guint changed = aGdkEvent->state ^ gButtonState;
+// Only consider button releases.
+// (Ignore button presses that occurred outside Gecko.)
+guint released = changed & gButtonState;
+gButtonState = aGdkEvent->state;
+// Loop over each button, excluding mouse wheel buttons 4 and 5 for which
+// GDK ignores releases.
+for (guint buttonMask = GDK_BUTTON1_MASK;
+buttonMask <= GDK_BUTTON3_MASK;
+buttonMask <<= 1) {
+if (released & buttonMask) {
+int16_t buttonType;
+switch (buttonMask) {
+case GDK_BUTTON1_MASK:
+buttonType = WidgetMouseEvent::eLeftButton;
+break;
+case GDK_BUTTON2_MASK:
+buttonType = WidgetMouseEvent::eMiddleButton;
+break;
+default:
+NS_ASSERTION(buttonMask == GDK_BUTTON3_MASK,
+"Unexpected button mask");
+buttonType = WidgetMouseEvent::eRightButton;
+}
+LOG(("Synthesized button %u release on %p\n",
+guint(buttonType + 1), (void *)this));
+// Dispatch a synthesized button up event to tell Gecko about the
+// change in state.  This event is marked as synthesized so that
+// it is not dispatched as a DOM event, because we don't know the
+// position, widget, modifiers, or time/order.
+WidgetMouseEvent synthEvent(true, NS_MOUSE_BUTTON_UP, this,
+WidgetMouseEvent::eSynthesized);
+synthEvent.button = buttonType;
+nsEventStatus status;
+DispatchEvent(&synthEvent, status);
+}
+}
+}
+void
+nsWindow::InitButtonEvent(WidgetMouseEvent& aEvent,
+GdkEventButton* aGdkEvent)
+{
+// XXX see OnScrollEvent()
+if (aGdkEvent->window == mGdkWindow) {
+aEvent.refPoint.x = nscoord(aGdkEvent->x);
+aEvent.refPoint.y = nscoord(aGdkEvent->y);
+} else {
+LayoutDeviceIntPoint point(NSToIntFloor(aGdkEvent->x_root),
+NSToIntFloor(aGdkEvent->y_root));
+aEvent.refPoint = point -
+LayoutDeviceIntPoint::FromUntyped(WidgetToScreenOffset());
+}
+guint modifierState = aGdkEvent->state;
+// aEvent's state doesn't include this event's information.  Therefore,
+// if aEvent is mouse button down event, we need to set it manually.
+// Note that we cannot do same thing for NS_MOUSE_BUTTON_UP because
+// system may have two or more mice and same button of another mouse
+// may be still pressed.
+if (aGdkEvent->type != GDK_BUTTON_RELEASE) {
+switch (aGdkEvent->button) {
+case 1:
+modifierState |= GDK_BUTTON1_MASK;
+break;
+case 2:
+modifierState |= GDK_BUTTON2_MASK;
+break;
+case 3:
+modifierState |= GDK_BUTTON3_MASK;
+break;
+}
+}
+KeymapWrapper::InitInputEvent(aEvent, modifierState);
+aEvent.time = aGdkEvent->time;
+switch (aGdkEvent->type) {
+case GDK_2BUTTON_PRESS:
+aEvent.clickCount = 2;
+break;
+case GDK_3BUTTON_PRESS:
+aEvent.clickCount = 3;
+break;
+// default is one click
+default:
+aEvent.clickCount = 1;
+}
+}
+static guint ButtonMaskFromGDKButton(guint button)
+{
+return GDK_BUTTON1_MASK << (button - 1);
+}
+void
+nsWindow::OnButtonPressEvent(GdkEventButton *aEvent)
+{
+LOG(("Button %u press on %p\n", aEvent->button, (void *)this));
+nsEventStatus status;
+// If you double click in GDK, it will actually generate a second
+// GDK_BUTTON_PRESS before sending the GDK_2BUTTON_PRESS, and this is
+// different than the DOM spec.  GDK puts this in the queue
+// programatically, so it's safe to assume that if there's a
+// double click in the queue, it was generated so we can just drop
+// this click.
+GdkEvent *peekedEvent = gdk_event_peek();
+if (peekedEvent) {
+GdkEventType type = peekedEvent->any.type;
+gdk_event_free(peekedEvent);
+if (type == GDK_2BUTTON_PRESS || type == GDK_3BUTTON_PRESS)
+return;
+}
+nsWindow *containerWindow = GetContainerWindow();
+if (!gFocusWindow && containerWindow) {
+containerWindow->DispatchActivateEvent();
+}
+// check to see if we should rollup
+if (CheckForRollup(aEvent->x_root, aEvent->y_root, false, false))
+return;
+gdouble pressure = 0;
+gdk_event_get_axis ((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure);
+mLastMotionPressure = pressure;
+uint16_t domButton;
+switch (aEvent->button) {
+case 1:
+domButton = WidgetMouseEvent::eLeftButton;
+break;
+case 2:
+domButton = WidgetMouseEvent::eMiddleButton;
+break;
+case 3:
+domButton = WidgetMouseEvent::eRightButton;
+break;
+// These are mapped to horizontal scroll
+case 6:
+case 7:
+NS_WARNING("We're not supporting legacy horizontal scroll event");
+return;
+// Map buttons 8-9 to back/forward
+case 8:
+DispatchCommandEvent(nsGkAtoms::Back);
+return;
+case 9:
+DispatchCommandEvent(nsGkAtoms::Forward);
+return;
+default:
+return;
+}
+gButtonState |= ButtonMaskFromGDKButton(aEvent->button);
+WidgetMouseEvent event(true, NS_MOUSE_BUTTON_DOWN, this,
+WidgetMouseEvent::eReal);
+event.button = domButton;
+InitButtonEvent(event, aEvent);
+event.pressure = mLastMotionPressure;
+DispatchEvent(&event, status);
+// right menu click on linux should also pop up a context menu
+if (domButton == WidgetMouseEvent::eRightButton &&
+MOZ_LIKELY(!mIsDestroyed)) {
+WidgetMouseEvent contextMenuEvent(true, NS_CONTEXTMENU, this,
+WidgetMouseEvent::eReal);
+InitButtonEvent(contextMenuEvent, aEvent);
+contextMenuEvent.pressure = mLastMotionPressure;
+DispatchEvent(&contextMenuEvent, status);
+}
+}
+void
+nsWindow::OnButtonReleaseEvent(GdkEventButton *aEvent)
+{
+LOG(("Button %u release on %p\n", aEvent->button, (void *)this));
+uint16_t domButton;
+switch (aEvent->button) {
+case 1:
+domButton = WidgetMouseEvent::eLeftButton;
+break;
+case 2:
+domButton = WidgetMouseEvent::eMiddleButton;
+break;
+case 3:
+domButton = WidgetMouseEvent::eRightButton;
+break;
+default:
+return;
+}
+gButtonState &= ~ButtonMaskFromGDKButton(aEvent->button);
+WidgetMouseEvent event(true, NS_MOUSE_BUTTON_UP, this,
+WidgetMouseEvent::eReal);
+event.button = domButton;
+InitButtonEvent(event, aEvent);
+gdouble pressure = 0;
+gdk_event_get_axis ((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure);
+event.pressure = pressure ? pressure : mLastMotionPressure;
+nsEventStatus status;
+DispatchEvent(&event, status);
+mLastMotionPressure = pressure;
+}
+void
+nsWindow::OnContainerFocusInEvent(GdkEventFocus *aEvent)
+{
+LOGFOCUS(("OnContainerFocusInEvent [%p]\n", (void *)this));
+// Unset the urgency hint, if possible
+GtkWidget* top_window = GetToplevelWidget();
+if (top_window && (gtk_widget_get_visible(top_window)))
+SetUrgencyHint(top_window, false);
+// Return if being called within SetFocus because the focus manager
+// already knows that the window is active.
+if (gBlockActivateEvent) {
+LOGFOCUS(("activated notification is blocked [%p]\n", (void *)this));
+return;
+}
+// If keyboard input will be accepted, the focus manager will call
+// SetFocus to set the correct window.
+gFocusWindow = nullptr;
+DispatchActivateEvent();
+if (!gFocusWindow) {
+// We don't really have a window for dispatching key events, but
+// setting a non-nullptr value here prevents OnButtonPressEvent() from
+// dispatching an activation notification if the widget is already
+// active.
+gFocusWindow = this;
+}
+LOGFOCUS(("Events sent from focus in event [%p]\n", (void *)this));
+}
+void
+nsWindow::OnContainerFocusOutEvent(GdkEventFocus *aEvent)
+{
+LOGFOCUS(("OnContainerFocusOutEvent [%p]\n", (void *)this));
+if (mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog) {
+nsCOMPtr<nsIDragService> dragService = do_GetService(kCDragServiceCID);
+nsCOMPtr<nsIDragSession> dragSession;
+dragService->GetCurrentSession(getter_AddRefs(dragSession));
+// Rollup popups when a window is focused out unless a drag is occurring.
+// This check is because drags grab the keyboard and cause a focus out on
+// versions of GTK before 2.18.
+bool shouldRollup = !dragSession;
+if (!shouldRollup) {
+// we also roll up when a drag is from a different application
+nsCOMPtr<nsIDOMNode> sourceNode;
+dragSession->GetSourceNode(getter_AddRefs(sourceNode));
+shouldRollup = (sourceNode == nullptr);
+}
+if (shouldRollup) {
+CheckForRollup(0, 0, false, true);
+}
+}
+#if (MOZ_WIDGET_GTK == 2) && defined(MOZ_X11)
+// plugin lose focus
+if (gPluginFocusWindow) {
+nsRefPtr<nsWindow> kungFuDeathGrip = gPluginFocusWindow;
+gPluginFocusWindow->LoseNonXEmbedPluginFocus();
+}
+#endif /* MOZ_X11 && MOZ_WIDGET_GTK2 */
+if (gFocusWindow) {
+nsRefPtr<nsWindow> kungFuDeathGrip = gFocusWindow;
+if (gFocusWindow->mIMModule) {
+gFocusWindow->mIMModule->OnBlurWindow(gFocusWindow);
+}
+gFocusWindow = nullptr;
+}
+DispatchDeactivateEvent();
+LOGFOCUS(("Done with container focus out [%p]\n", (void *)this));
+}
+bool
+nsWindow::DispatchCommandEvent(nsIAtom* aCommand)
+{
+nsEventStatus status;
+WidgetCommandEvent event(true, nsGkAtoms::onAppCommand, aCommand, this);
+DispatchEvent(&event, status);
+return TRUE;
+}
+bool
+nsWindow::DispatchContentCommandEvent(int32_t aMsg)
+{
+nsEventStatus status;
+WidgetContentCommandEvent event(true, aMsg, this);
+DispatchEvent(&event, status);
+return TRUE;
+}
+static bool
+IsCtrlAltTab(GdkEventKey *aEvent)
+{
+return aEvent->keyval == GDK_Tab &&
+KeymapWrapper::AreModifiersActive(
+KeymapWrapper::CTRL | KeymapWrapper::ALT, aEvent->state);
+}
+bool
+nsWindow::DispatchKeyDownEvent(GdkEventKey *aEvent, bool *aCancelled)
+{
+NS_PRECONDITION(aCancelled, "aCancelled must not be null");
+*aCancelled = false;
+if (IsCtrlAltTab(aEvent)) {
+return false;
+}
+// send the key down event
+nsEventStatus status;
+WidgetKeyboardEvent downEvent(true, NS_KEY_DOWN, this);
+KeymapWrapper::InitKeyEvent(downEvent, aEvent);
+DispatchEvent(&downEvent, status);
+*aCancelled = (status == nsEventStatus_eConsumeNoDefault);
+return true;
+}
+gboolean
+nsWindow::OnKeyPressEvent(GdkEventKey *aEvent)
+{
+LOGFOCUS(("OnKeyPressEvent [%p]\n", (void *)this));
+// if we are in the middle of composing text, XIM gets to see it
+// before mozilla does.
+bool IMEWasEnabled = false;
+if (mIMModule) {
+IMEWasEnabled = mIMModule->IsEnabled();
+if (mIMModule->OnKeyEvent(this, aEvent)) {
+return TRUE;
+}
+}
+nsEventStatus status;
+// work around for annoying things.
+if (IsCtrlAltTab(aEvent)) {
+return TRUE;
+}
+nsCOMPtr<nsIWidget> kungFuDeathGrip = this;
+// Dispatch keydown event always.  At auto repeating, we should send
+// KEYDOWN -> KEYPRESS -> KEYDOWN -> KEYPRESS ... -> KEYUP
+// However, old distributions (e.g., Ubuntu 9.10) sent native key
+// release event, so, on such platform, the DOM events will be:
+// KEYDOWN -> KEYPRESS -> KEYUP -> KEYDOWN -> KEYPRESS -> KEYUP...
+bool isKeyDownCancelled = false;
+if (DispatchKeyDownEvent(aEvent, &isKeyDownCancelled) &&
+(MOZ_UNLIKELY(mIsDestroyed) || isKeyDownCancelled)) {
+return TRUE;
+}
+// If a keydown event handler causes to enable IME, i.e., it moves
+// focus from IME unusable content to IME usable editor, we should
+// send the native key event to IME for the first input on the editor.
+if (!IMEWasEnabled && mIMModule && mIMModule->IsEnabled()) {
+// Notice our keydown event was already dispatched.  This prevents
+// unnecessary DOM keydown event in the editor.
+if (mIMModule->OnKeyEvent(this, aEvent, true)) {
+return TRUE;
+}
+}
+// Don't pass modifiers as NS_KEY_PRESS events.
+// TODO: Instead of selectively excluding some keys from NS_KEY_PRESS events,
+//       we should instead selectively include (as per MSDN spec; no official
+//       spec covers KeyPress events).
+if (!KeymapWrapper::IsKeyPressEventNecessary(aEvent)) {
+return TRUE;
+}
+#ifdef MOZ_X11
+#if ! defined AIX // no XFree86 on AIX 5L
+// Look for specialized app-command keys
+switch (aEvent->keyval) {
+case XF86XK_Back:
+return DispatchCommandEvent(nsGkAtoms::Back);
+case XF86XK_Forward:
+return DispatchCommandEvent(nsGkAtoms::Forward);
+case XF86XK_Refresh:
+return DispatchCommandEvent(nsGkAtoms::Reload);
+case XF86XK_Stop:
+return DispatchCommandEvent(nsGkAtoms::Stop);
+case XF86XK_Search:
+return DispatchCommandEvent(nsGkAtoms::Search);
+case XF86XK_Favorites:
+return DispatchCommandEvent(nsGkAtoms::Bookmarks);
+case XF86XK_HomePage:
+return DispatchCommandEvent(nsGkAtoms::Home);
+case XF86XK_Copy:
+case GDK_F16:  // F16, F20, F18, F14 are old keysyms for Copy Cut Paste Undo
+return DispatchContentCommandEvent(NS_CONTENT_COMMAND_COPY);
+case XF86XK_Cut:
+case GDK_F20:
+return DispatchContentCommandEvent(NS_CONTENT_COMMAND_CUT);
+case XF86XK_Paste:
+case GDK_F18:
+return DispatchContentCommandEvent(NS_CONTENT_COMMAND_PASTE);
+case GDK_Redo:
+return DispatchContentCommandEvent(NS_CONTENT_COMMAND_REDO);
+case GDK_Undo:
+case GDK_F14:
+return DispatchContentCommandEvent(NS_CONTENT_COMMAND_UNDO);
+}
+#endif /* ! AIX */
+#endif /* MOZ_X11 */
+WidgetKeyboardEvent event(true, NS_KEY_PRESS, this);
+KeymapWrapper::InitKeyEvent(event, aEvent);
+// before we dispatch a key, check if it's the context menu key.
+// If so, send a context menu key event instead.
+if (is_context_menu_key(event)) {
+WidgetMouseEvent contextMenuEvent(true, NS_CONTEXTMENU, this,
+WidgetMouseEvent::eReal,
+WidgetMouseEvent::eContextMenuKey);
+contextMenuEvent.refPoint = LayoutDeviceIntPoint(0, 0);
+contextMenuEvent.time = aEvent->time;
+contextMenuEvent.clickCount = 1;
+KeymapWrapper::InitInputEvent(contextMenuEvent, aEvent->state);
+DispatchEvent(&contextMenuEvent, status);
+}
+else {
+// If the character code is in the BMP, send the key press event.
+// Otherwise, send a text event with the equivalent UTF-16 string.
+if (IS_IN_BMP(event.charCode)) {
+DispatchEvent(&event, status);
+}
+else {
+WidgetTextEvent textEvent(true, NS_TEXT_TEXT, this);
+char16_t textString[3];
+textString[0] = H_SURROGATE(event.charCode);
+textString[1] = L_SURROGATE(event.charCode);
+textString[2] = 0;
+textEvent.theText = textString;
+textEvent.time = event.time;
+DispatchEvent(&textEvent, status);
+}
+}
+// If the event was consumed, return.
+if (status == nsEventStatus_eConsumeNoDefault) {
+return TRUE;
+}
+return FALSE;
+}
+gboolean
+nsWindow::OnKeyReleaseEvent(GdkEventKey *aEvent)
+{
+LOGFOCUS(("OnKeyReleaseEvent [%p]\n", (void *)this));
+if (mIMModule && mIMModule->OnKeyEvent(this, aEvent)) {
+return TRUE;
+}
+// send the key event as a key up event
+WidgetKeyboardEvent event(true, NS_KEY_UP, this);
+KeymapWrapper::InitKeyEvent(event, aEvent);
+nsEventStatus status;
+DispatchEvent(&event, status);
+// If the event was consumed, return.
+if (status == nsEventStatus_eConsumeNoDefault) {
+return TRUE;
+}
+return FALSE;
+}
+void
+nsWindow::OnScrollEvent(GdkEventScroll *aEvent)
+{
+// check to see if we should rollup
+if (CheckForRollup(aEvent->x_root, aEvent->y_root, true, false))
+return;
+WidgetWheelEvent wheelEvent(true, NS_WHEEL_WHEEL, this);
+wheelEvent.deltaMode = nsIDOMWheelEvent::DOM_DELTA_LINE;
+switch (aEvent->direction) {
+case GDK_SCROLL_UP:
+wheelEvent.deltaY = wheelEvent.lineOrPageDeltaY = -3;
+break;
+case GDK_SCROLL_DOWN:
+wheelEvent.deltaY = wheelEvent.lineOrPageDeltaY = 3;
+break;
+case GDK_SCROLL_LEFT:
+wheelEvent.deltaX = wheelEvent.lineOrPageDeltaX = -1;
+break;
+case GDK_SCROLL_RIGHT:
+wheelEvent.deltaX = wheelEvent.lineOrPageDeltaX = 1;
+break;
+}
+NS_ASSERTION(wheelEvent.deltaX || wheelEvent.deltaY,
+"deltaX or deltaY must be non-zero");
+if (aEvent->window == mGdkWindow) {
+// we are the window that the event happened on so no need for expensive WidgetToScreenOffset
+wheelEvent.refPoint.x = nscoord(aEvent->x);
+wheelEvent.refPoint.y = nscoord(aEvent->y);
+} else {
+// XXX we're never quite sure which GdkWindow the event came from due to our custom bubbling
+// in scroll_event_cb(), so use ScreenToWidget to translate the screen root coordinates into
+// coordinates relative to this widget.
+LayoutDeviceIntPoint point(NSToIntFloor(aEvent->x_root),
+NSToIntFloor(aEvent->y_root));
+wheelEvent.refPoint = point -
+LayoutDeviceIntPoint::FromUntyped(WidgetToScreenOffset());
+}
+KeymapWrapper::InitInputEvent(wheelEvent, aEvent->state);
+wheelEvent.time = aEvent->time;
+nsEventStatus status;
+DispatchEvent(&wheelEvent, status);
+}
+void
+nsWindow::OnVisibilityNotifyEvent(GdkEventVisibility *aEvent)
+{
+LOGDRAW(("Visibility event %i on [%p] %p\n",
+aEvent->state, this, aEvent->window));
+if (!mGdkWindow)
+return;
+switch (aEvent->state) {
+case GDK_VISIBILITY_UNOBSCURED:
+case GDK_VISIBILITY_PARTIAL:
+if (mIsFullyObscured && mHasMappedToplevel) {
+// GDK_EXPOSE events have been ignored, so make sure GDK
+// doesn't think that the window has already been painted.
+gdk_window_invalidate_rect(mGdkWindow, nullptr, FALSE);
+}
+mIsFullyObscured = false;
+if (!nsGtkIMModule::IsVirtualKeyboardOpened()) {
+// if we have to retry the grab, retry it.
+EnsureGrabs();
+}
+break;
+default: // includes GDK_VISIBILITY_FULLY_OBSCURED
+mIsFullyObscured = true;
+break;
+}
+}
+void
+nsWindow::OnWindowStateEvent(GtkWidget *aWidget, GdkEventWindowState *aEvent)
+{
+LOG(("nsWindow::OnWindowStateEvent [%p] changed %d new_window_state %d\n",
+(void *)this, aEvent->changed_mask, aEvent->new_window_state));
+if (IS_MOZ_CONTAINER(aWidget)) {
+// This event is notifying the container widget of changes to the
+// toplevel window.  Just detect changes affecting whether windows are
+// viewable.
+//
+// (A visibility notify event is sent to each window that becomes
+// viewable when the toplevel is mapped, but we can't rely on that for
+// setting mHasMappedToplevel because these toplevel window state
+// events are asynchronous.  The windows in the hierarchy now may not
+// be the same windows as when the toplevel was mapped, so they may
+// not get VisibilityNotify events.)
+bool mapped =
+!(aEvent->new_window_state &
+(GDK_WINDOW_STATE_ICONIFIED|GDK_WINDOW_STATE_WITHDRAWN));
+if (mHasMappedToplevel != mapped) {
+SetHasMappedToplevel(mapped);
+}
+return;
+}
+// else the widget is a shell widget.
+// We don't care about anything but changes in the maximized/icon/fullscreen
+// states
+if ((aEvent->changed_mask
+& (GDK_WINDOW_STATE_ICONIFIED |
+GDK_WINDOW_STATE_MAXIMIZED |
+GDK_WINDOW_STATE_FULLSCREEN)) == 0) {
+return;
+}
+if (aEvent->new_window_state & GDK_WINDOW_STATE_ICONIFIED) {
+LOG(("\tIconified\n"));
+mSizeState = nsSizeMode_Minimized;
+#ifdef ACCESSIBILITY
+DispatchMinimizeEventAccessible();
+#endif //ACCESSIBILITY
+}
+else if (aEvent->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
+LOG(("\tFullscreen\n"));
+mSizeState = nsSizeMode_Fullscreen;
+}
+else if (aEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) {
+LOG(("\tMaximized\n"));
+mSizeState = nsSizeMode_Maximized;
+#ifdef ACCESSIBILITY
+DispatchMaximizeEventAccessible();
+#endif //ACCESSIBILITY
+}
+else {
+LOG(("\tNormal\n"));
+mSizeState = nsSizeMode_Normal;
+#ifdef ACCESSIBILITY
+DispatchRestoreEventAccessible();
+#endif //ACCESSIBILITY
+}
+if (mWidgetListener)
+mWidgetListener->SizeModeChanged(mSizeState);
+}
+void
+nsWindow::ThemeChanged()
+{
+NotifyThemeChanged();
+if (!mGdkWindow || MOZ_UNLIKELY(mIsDestroyed))
+return;
+// Dispatch theme change notification to all child windows
+GList *children =
+gdk_window_peek_children(mGdkWindow);
+while (children) {
+GdkWindow *gdkWin = GDK_WINDOW(children->data);
+nsWindow *win = (nsWindow*) g_object_get_data(G_OBJECT(gdkWin),
+"nsWindow");
+if (win && win != this) { // guard against infinite recursion
+nsRefPtr<nsWindow> kungFuDeathGrip = win;
+win->ThemeChanged();
+}
+children = children->next;
+}
+}
+void
+nsWindow::DispatchDragEvent(uint32_t aMsg, const nsIntPoint& aRefPoint,
+guint aTime)
+{
+WidgetDragEvent event(true, aMsg, this);
+if (aMsg == NS_DRAGDROP_OVER) {
+InitDragEvent(event);
+}
+event.refPoint = LayoutDeviceIntPoint::FromUntyped(aRefPoint);
+event.time = aTime;
+nsEventStatus status;
+DispatchEvent(&event, status);
+}
+void
+nsWindow::OnDragDataReceivedEvent(GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+GtkSelectionData  *aSelectionData,
+guint aInfo,
+guint aTime,
+gpointer aData)
+{
+LOGDRAG(("nsWindow::OnDragDataReceived(%p)\n", (void*)this));
+nsDragService::GetInstance()->
+TargetDataReceived(aWidget, aDragContext, aX, aY,
+aSelectionData, aInfo, aTime);
+}
+static void
+GetBrandName(nsXPIDLString& brandName)
+{
+nsCOMPtr<nsIStringBundleService> bundleService =
+do_GetService(NS_STRINGBUNDLE_CONTRACTID);
+nsCOMPtr<nsIStringBundle> bundle;
+if (bundleService)
+bundleService->CreateBundle(
+"chrome://branding/locale/brand.properties",
+getter_AddRefs(bundle));
+if (bundle)
+bundle->GetStringFromName(
+MOZ_UTF16("brandShortName"),
+getter_Copies(brandName));
+if (brandName.IsEmpty())
+brandName.Assign(NS_LITERAL_STRING("Mozilla"));
+}
+static GdkWindow *
+CreateGdkWindow(GdkWindow *parent, GtkWidget *widget)
+{
+GdkWindowAttr attributes;
+gint          attributes_mask = GDK_WA_VISUAL;
+attributes.event_mask = kEvents;
+attributes.width = 1;
+attributes.height = 1;
+attributes.wclass = GDK_INPUT_OUTPUT;
+attributes.visual = gtk_widget_get_visual(widget);
+attributes.window_type = GDK_WINDOW_CHILD;
+#if (MOZ_WIDGET_GTK == 2)
+attributes_mask |= GDK_WA_COLORMAP;
+attributes.colormap = gtk_widget_get_colormap(widget);
+#endif
+GdkWindow *window = gdk_window_new(parent, &attributes, attributes_mask);
+gdk_window_set_user_data(window, widget);
+// GTK3 TODO?
+#if (MOZ_WIDGET_GTK == 2)
+/* set the default pixmap to None so that you don't end up with the
+gtk default which is BlackPixel. */
+gdk_window_set_back_pixmap(window, nullptr, FALSE);
+#endif
+return window;
+}
+nsresult
+nsWindow::Create(nsIWidget        *aParent,
+nsNativeWidget    aNativeParent,
+const nsIntRect  &aRect,
+nsDeviceContext *aContext,
+nsWidgetInitData *aInitData)
+{
+// only set the base parent if we're going to be a dialog or a
+// toplevel
+nsIWidget *baseParent = aInitData &&
+(aInitData->mWindowType == eWindowType_dialog ||
+aInitData->mWindowType == eWindowType_toplevel ||
+aInitData->mWindowType == eWindowType_invisible) ?
+nullptr : aParent;
+#ifdef ACCESSIBILITY
+// Send a DBus message to check whether a11y is enabled
+a11y::PreInit();
+#endif
+// Ensure that the toolkit is created.
+nsGTKToolkit::GetToolkit();
+// initialize all the common bits of this class
+BaseCreate(baseParent, aRect, aContext, aInitData);
+// Do we need to listen for resizes?
+bool listenForResizes = false;;
+if (aNativeParent || (aInitData && aInitData->mListenForResizes))
+listenForResizes = true;
+// and do our common creation
+CommonCreate(aParent, listenForResizes);
+// save our bounds
+mBounds = aRect;
+ConstrainSize(&mBounds.width, &mBounds.height);
+// figure out our parent window
+GtkWidget      *parentMozContainer = nullptr;
+GtkContainer   *parentGtkContainer = nullptr;
+GdkWindow      *parentGdkWindow = nullptr;
+GtkWindow      *topLevelParent = nullptr;
+nsWindow       *parentnsWindow = nullptr;
+GtkWidget      *eventWidget = nullptr;
+if (aParent) {
+parentnsWindow = static_cast<nsWindow*>(aParent);
+parentGdkWindow = parentnsWindow->mGdkWindow;
+} else if (aNativeParent && GDK_IS_WINDOW(aNativeParent)) {
+parentGdkWindow = GDK_WINDOW(aNativeParent);
+parentnsWindow = get_window_for_gdk_window(parentGdkWindow);
+if (!parentnsWindow)
+return NS_ERROR_FAILURE;
+} else if (aNativeParent && GTK_IS_CONTAINER(aNativeParent)) {
+parentGtkContainer = GTK_CONTAINER(aNativeParent);
+}
+if (parentGdkWindow) {
+// get the widget for the window - it should be a moz container
+parentMozContainer = parentnsWindow->GetMozContainerWidget();
+if (!parentMozContainer)
+return NS_ERROR_FAILURE;
+// get the toplevel window just in case someone needs to use it
+// for setting transients or whatever.
+topLevelParent =
+GTK_WINDOW(gtk_widget_get_toplevel(parentMozContainer));
+}
+// ok, create our windows
+switch (mWindowType) {
+case eWindowType_dialog:
+case eWindowType_popup:
+case eWindowType_toplevel:
+case eWindowType_invisible: {
+mIsTopLevel = true;
+// We only move a general managed toplevel window if someone has
+// actually placed the window somewhere.  If no placement has taken
+// place, we just let the window manager Do The Right Thing.
+//
+// Indicate that if we're shown, we at least need to have our size set.
+// If we get explicitly moved, the position will also be set.
+mNeedsResize = true;
+if (mWindowType == eWindowType_dialog) {
+mShell = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+SetDefaultIcon();
+gtk_window_set_wmclass(GTK_WINDOW(mShell), "Dialog",
+gdk_get_program_class());
+gtk_window_set_type_hint(GTK_WINDOW(mShell),
+GDK_WINDOW_TYPE_HINT_DIALOG);
+gtk_window_set_transient_for(GTK_WINDOW(mShell),
+topLevelParent);
+}
+else if (mWindowType == eWindowType_popup) {
+// With popup windows, we want to control their position, so don't
+// wait for the window manager to place them (which wouldn't
+// happen with override-redirect windows anyway).
+mNeedsMove = true;
+// Popups that are not noautohide are only temporary. The are used
+// for menus and the like and disappear when another window is used.
+// For most popups, use the standard GtkWindowType GTK_WINDOW_POPUP,
+// which will use a Window with the override-redirect attribute
+// (for temporary windows).
+// For long-lived windows, their stacking order is managed by the
+// window manager, as indicated by GTK_WINDOW_TOPLEVEL ...
+GtkWindowType type = aInitData->mNoAutoHide ?
+GTK_WINDOW_TOPLEVEL : GTK_WINDOW_POPUP;
+mShell = gtk_window_new(type);
+gtk_window_set_wmclass(GTK_WINDOW(mShell), "Popup",
+gdk_get_program_class());
+if (aInitData->mSupportTranslucency) {
+// We need to select an ARGB visual here instead of in
+// SetTransparencyMode() because it has to be done before the
+// widget is realized.  An ARGB visual is only useful if we
+// are on a compositing window manager.
+GdkScreen *screen = gtk_widget_get_screen(mShell);
+if (gdk_screen_is_composited(screen)) {
+#if (MOZ_WIDGET_GTK == 2)
+GdkColormap *colormap =
+gdk_screen_get_rgba_colormap(screen);
+gtk_widget_set_colormap(mShell, colormap);
+#else
+GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
+gtk_widget_set_visual(mShell, visual);
+#endif
+}
+}
+if (aInitData->mNoAutoHide) {
+// ... but the window manager does not decorate this window,
+// nor provide a separate taskbar icon.
+if (mBorderStyle == eBorderStyle_default) {
+gtk_window_set_decorated(GTK_WINDOW(mShell), FALSE);
+}
+else {
+bool decorate = mBorderStyle & eBorderStyle_title;
+gtk_window_set_decorated(GTK_WINDOW(mShell), decorate);
+if (decorate) {
+gtk_window_set_deletable(GTK_WINDOW(mShell), mBorderStyle & eBorderStyle_close);
+}
+}
+gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mShell), TRUE);
+// Element focus is managed by the parent window so the
+// WM_HINTS input field is set to False to tell the window
+// manager not to set input focus to this window ...
+gtk_window_set_accept_focus(GTK_WINDOW(mShell), FALSE);
+#ifdef MOZ_X11
+// ... but when the window manager offers focus through
+// WM_TAKE_FOCUS, focus is requested on the parent window.
+gtk_widget_realize(mShell);
+gdk_window_add_filter(gtk_widget_get_window(mShell),
+popup_take_focus_filter, nullptr);
+#endif
+}
+GdkWindowTypeHint gtkTypeHint;
+if (aInitData->mIsDragPopup) {
+gtkTypeHint = GDK_WINDOW_TYPE_HINT_DND;
+}
+else {
+switch (aInitData->mPopupHint) {
+case ePopupTypeMenu:
+gtkTypeHint = GDK_WINDOW_TYPE_HINT_POPUP_MENU;
+break;
+case ePopupTypeTooltip:
+gtkTypeHint = GDK_WINDOW_TYPE_HINT_TOOLTIP;
+break;
+default:
+gtkTypeHint = GDK_WINDOW_TYPE_HINT_UTILITY;
+break;
+}
+}
+gtk_window_set_type_hint(GTK_WINDOW(mShell), gtkTypeHint);
+if (topLevelParent) {
+gtk_window_set_transient_for(GTK_WINDOW(mShell),
+topLevelParent);
+}
+}
+else { // must be eWindowType_toplevel
+mShell = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+SetDefaultIcon();
+gtk_window_set_wmclass(GTK_WINDOW(mShell), "Toplevel",
+gdk_get_program_class());
+// each toplevel window gets its own window group
+GtkWindowGroup *group = gtk_window_group_new();
+gtk_window_group_add_window(group, GTK_WINDOW(mShell));
+g_object_unref(group);
+}
+// Prevent GtkWindow from painting a background to flicker.
+gtk_widget_set_app_paintable(mShell, TRUE);
+// Create a container to hold child windows and child GtkWidgets.
+GtkWidget *container = moz_container_new();
+mContainer = MOZ_CONTAINER(container);
+// Use mShell's window for drawing and events.
+gtk_widget_set_has_window(container, FALSE);
+eventWidget = mShell;
+gtk_widget_add_events(eventWidget, kEvents);
+gtk_container_add(GTK_CONTAINER(mShell), container);
+gtk_widget_realize(container);
+// make sure this is the focus widget in the container
+gtk_widget_show(container);
+gtk_widget_grab_focus(container);
+// the drawing window
+mGdkWindow = gtk_widget_get_window(mShell);
+if (mWindowType == eWindowType_popup) {
+// gdk does not automatically set the cursor for "temporary"
+// windows, which are what gtk uses for popups.
+mCursor = eCursor_wait; // force SetCursor to actually set the
+// cursor, even though our internal state
+// indicates that we already have the
+// standard cursor.
+SetCursor(eCursor_standard);
+if (aInitData->mNoAutoHide) {
+gint wmd = ConvertBorderStyles(mBorderStyle);
+if (wmd != -1)
+gdk_window_set_decorations(gtk_widget_get_window(mShell), (GdkWMDecoration) wmd);
+}
+// If the popup ignores mouse events, set an empty input shape.
+if (aInitData->mMouseTransparent) {
+#if (MOZ_WIDGET_GTK == 2)
+GdkRectangle rect = { 0, 0, 0, 0 };
+GdkRegion *region = gdk_region_rectangle(&rect);
+gdk_window_input_shape_combine_region(mGdkWindow, region, 0, 0);
+gdk_region_destroy(region);
+#else
+cairo_rectangle_int_t rect = { 0, 0, 0, 0 };
+cairo_region_t *region = cairo_region_create_rectangle(&rect);
+gdk_window_input_shape_combine_region(mGdkWindow, region, 0, 0);
+cairo_region_destroy(region);
+#endif
+}
+}
+}
+break;
+case eWindowType_plugin:
+case eWindowType_child: {
+if (parentMozContainer) {
+mGdkWindow = CreateGdkWindow(parentGdkWindow, parentMozContainer);
+mHasMappedToplevel = parentnsWindow->mHasMappedToplevel;
+}
+else if (parentGtkContainer) {
+// This MozContainer has its own window for drawing and receives
+// events because there is no mShell widget (corresponding to this
+// nsWindow).
+GtkWidget *container = moz_container_new();
+mContainer = MOZ_CONTAINER(container);
+eventWidget = container;
+gtk_widget_add_events(eventWidget, kEvents);
+gtk_container_add(parentGtkContainer, container);
+gtk_widget_realize(container);
+mGdkWindow = gtk_widget_get_window(container);
+}
+else {
+NS_WARNING("Warning: tried to create a new child widget with no parent!");
+return NS_ERROR_FAILURE;
+}
+}
+break;
+default:
+break;
+}
+// label the drawing window with this object so we can find our way home
+g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", this);
+if (mContainer)
+g_object_set_data(G_OBJECT(mContainer), "nsWindow", this);
+if (mShell)
+g_object_set_data(G_OBJECT(mShell), "nsWindow", this);
+// attach listeners for events
+if (mShell) {
+g_signal_connect(mShell, "configure_event",
+G_CALLBACK(configure_event_cb), nullptr);
+g_signal_connect(mShell, "delete_event",
+G_CALLBACK(delete_event_cb), nullptr);
+g_signal_connect(mShell, "window_state_event",
+G_CALLBACK(window_state_event_cb), nullptr);
+GtkSettings* default_settings = gtk_settings_get_default();
+g_signal_connect_after(default_settings,
+"notify::gtk-theme-name",
+G_CALLBACK(theme_changed_cb), this);
+g_signal_connect_after(default_settings,
+"notify::gtk-font-name",
+G_CALLBACK(theme_changed_cb), this);
+}
+if (mContainer) {
+// Widget signals
+g_signal_connect(mContainer, "unrealize",
+G_CALLBACK(container_unrealize_cb), nullptr);
+g_signal_connect_after(mContainer, "size_allocate",
+G_CALLBACK(size_allocate_cb), nullptr);
+g_signal_connect(mContainer, "hierarchy-changed",
+G_CALLBACK(hierarchy_changed_cb), nullptr);
+// Initialize mHasMappedToplevel.
+hierarchy_changed_cb(GTK_WIDGET(mContainer), nullptr);
+// Expose, focus, key, and drag events are sent even to GTK_NO_WINDOW
+// widgets.
+#if (MOZ_WIDGET_GTK == 2)
+g_signal_connect(mContainer, "expose_event",
+G_CALLBACK(expose_event_cb), nullptr);
+#else
+g_signal_connect(G_OBJECT(mContainer), "draw",
+G_CALLBACK(expose_event_cb), nullptr);
+#endif
+g_signal_connect(mContainer, "focus_in_event",
+G_CALLBACK(focus_in_event_cb), nullptr);
+g_signal_connect(mContainer, "focus_out_event",
+G_CALLBACK(focus_out_event_cb), nullptr);
+g_signal_connect(mContainer, "key_press_event",
+G_CALLBACK(key_press_event_cb), nullptr);
+g_signal_connect(mContainer, "key_release_event",
+G_CALLBACK(key_release_event_cb), nullptr);
+gtk_drag_dest_set((GtkWidget *)mContainer,
+(GtkDestDefaults)0,
+nullptr,
+0,
+(GdkDragAction)0);
+g_signal_connect(mContainer, "drag_motion",
+G_CALLBACK(drag_motion_event_cb), nullptr);
+g_signal_connect(mContainer, "drag_leave",
+G_CALLBACK(drag_leave_event_cb), nullptr);
+g_signal_connect(mContainer, "drag_drop",
+G_CALLBACK(drag_drop_event_cb), nullptr);
+g_signal_connect(mContainer, "drag_data_received",
+G_CALLBACK(drag_data_received_event_cb), nullptr);
+GtkWidget *widgets[] = { GTK_WIDGET(mContainer), mShell };
+for (size_t i = 0; i < ArrayLength(widgets) && widgets[i]; ++i) {
+// Visibility events are sent to the owning widget of the relevant
+// window but do not propagate to parent widgets so connect on
+// mShell (if it exists) as well as mContainer.
+g_signal_connect(widgets[i], "visibility-notify-event",
+G_CALLBACK(visibility_notify_event_cb), nullptr);
+// Similarly double buffering is controlled by the window's owning
+// widget.  Disable double buffering for painting directly to the
+// X Window.
+gtk_widget_set_double_buffered(widgets[i], FALSE);
+}
+// We create input contexts for all containers, except for
+// toplevel popup windows
+if (mWindowType != eWindowType_popup) {
+mIMModule = new nsGtkIMModule(this);
+}
+} else if (!mIMModule) {
+nsWindow *container = GetContainerWindow();
+if (container) {
+mIMModule = container->mIMModule;
+}
+}
+if (eventWidget) {
+#if (MOZ_WIDGET_GTK == 2)
+// Don't let GTK mess with the shapes of our GdkWindows
+GTK_PRIVATE_SET_FLAG(eventWidget, GTK_HAS_SHAPE_MASK);
+#endif
+// These events are sent to the owning widget of the relevant window
+// and propagate up to the first widget that handles the events, so we
+// need only connect on mShell, if it exists, to catch events on its
+// window and windows of mContainer.
+g_signal_connect(eventWidget, "enter-notify-event",
+G_CALLBACK(enter_notify_event_cb), nullptr);
+g_signal_connect(eventWidget, "leave-notify-event",
+G_CALLBACK(leave_notify_event_cb), nullptr);
+g_signal_connect(eventWidget, "motion-notify-event",
+G_CALLBACK(motion_notify_event_cb), nullptr);
+g_signal_connect(eventWidget, "button-press-event",
+G_CALLBACK(button_press_event_cb), nullptr);
+g_signal_connect(eventWidget, "button-release-event",
+G_CALLBACK(button_release_event_cb), nullptr);
+g_signal_connect(eventWidget, "scroll-event",
+G_CALLBACK(scroll_event_cb), nullptr);
+}
+LOG(("nsWindow [%p]\n", (void *)this));
+if (mShell) {
+LOG(("\tmShell %p mContainer %p mGdkWindow %p 0x%lx\n",
+mShell, mContainer, mGdkWindow,
+gdk_x11_window_get_xid(mGdkWindow)));
+} else if (mContainer) {
+LOG(("\tmContainer %p mGdkWindow %p\n", mContainer, mGdkWindow));
+}
+else if (mGdkWindow) {
+LOG(("\tmGdkWindow %p parent %p\n",
+mGdkWindow, gdk_window_get_parent(mGdkWindow)));
+}
+// resize so that everything is set to the right dimensions
+if (!mIsTopLevel)
+Resize(mBounds.x, mBounds.y, mBounds.width, mBounds.height, false);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::SetWindowClass(const nsAString &xulWinType)
+{
+if (!mShell)
+return NS_ERROR_FAILURE;
+const char *res_class = gdk_get_program_class();
+if (!res_class)
+return NS_ERROR_FAILURE;
+char *res_name = ToNewCString(xulWinType);
+if (!res_name)
+return NS_ERROR_OUT_OF_MEMORY;
+const char *role = nullptr;
+// Parse res_name into a name and role. Characters other than
+// [A-Za-z0-9_-] are converted to '_'. Anything after the first
+// colon is assigned to role; if there's no colon, assign the
+// whole thing to both role and res_name.
+for (char *c = res_name; *c; c++) {
+if (':' == *c) {
+*c = 0;
+role = c + 1;
+}
+else if (!isascii(*c) || (!isalnum(*c) && ('_' != *c) && ('-' != *c)))
+*c = '_';
+}
+res_name[0] = toupper(res_name[0]);
+if (!role) role = res_name;
+GdkWindow *shellWindow = gtk_widget_get_window(GTK_WIDGET(mShell));
+gdk_window_set_role(shellWindow, role);
+#ifdef MOZ_X11
+XClassHint *class_hint = XAllocClassHint();
+if (!class_hint) {
+nsMemory::Free(res_name);
+return NS_ERROR_OUT_OF_MEMORY;
+}
+class_hint->res_name = res_name;
+class_hint->res_class = const_cast<char*>(res_class);
+// Can't use gtk_window_set_wmclass() for this; it prints
+// a warning & refuses to make the change.
+XSetClassHint(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
+gdk_x11_window_get_xid(shellWindow),
+class_hint);
+XFree(class_hint);
+#endif /* MOZ_X11 */
+nsMemory::Free(res_name);
+return NS_OK;
+}
+void
+nsWindow::NativeResize(int32_t aWidth, int32_t aHeight, bool    aRepaint)
+{
+LOG(("nsWindow::NativeResize [%p] %d %d\n", (void *)this,
+aWidth, aHeight));
+// clear our resize flag
+mNeedsResize = false;
+if (mIsTopLevel) {
+gtk_window_resize(GTK_WINDOW(mShell), aWidth, aHeight);
+}
+else if (mContainer) {
+GtkWidget *widget = GTK_WIDGET(mContainer);
+GtkAllocation allocation, prev_allocation;
+gtk_widget_get_allocation(widget, &prev_allocation);
+allocation.x = prev_allocation.x;
+allocation.y = prev_allocation.y;
+allocation.width = aWidth;
+allocation.height = aHeight;
+gtk_widget_size_allocate(widget, &allocation);
+}
+else if (mGdkWindow) {
+gdk_window_resize(mGdkWindow, aWidth, aHeight);
+}
+}
+void
+nsWindow::NativeResize(int32_t aX, int32_t aY,
+int32_t aWidth, int32_t aHeight,
+bool    aRepaint)
+{
+mNeedsResize = false;
+mNeedsMove = false;
+LOG(("nsWindow::NativeResize [%p] %d %d %d %d\n", (void *)this,
+aX, aY, aWidth, aHeight));
+if (mIsTopLevel) {
+// aX and aY give the position of the window manager frame top-left.
+gtk_window_move(GTK_WINDOW(mShell), aX, aY);
+// This sets the client window size.
+gtk_window_resize(GTK_WINDOW(mShell), aWidth, aHeight);
+}
+else if (mContainer) {
+GtkAllocation allocation;
+allocation.x = aX;
+allocation.y = aY;
+allocation.width = aWidth;
+allocation.height = aHeight;
+gtk_widget_size_allocate(GTK_WIDGET(mContainer), &allocation);
+}
+else if (mGdkWindow) {
+gdk_window_move_resize(mGdkWindow, aX, aY, aWidth, aHeight);
+}
+}
+void
+nsWindow::NativeShow(bool aAction)
+{
+if (aAction) {
+// unset our flag now that our window has been shown
+mNeedsShow = false;
+if (mIsTopLevel) {
+// Set up usertime/startupID metadata for the created window.
+if (mWindowType != eWindowType_invisible) {
+SetUserTimeAndStartupIDForActivatedWindow(mShell);
+}
+gtk_widget_show(mShell);
+}
+else if (mContainer) {
+gtk_widget_show(GTK_WIDGET(mContainer));
+}
+else if (mGdkWindow) {
+gdk_window_show_unraised(mGdkWindow);
+}
+}
+else {
+if (mIsTopLevel) {
+gtk_widget_hide(GTK_WIDGET(mShell));
+ClearTransparencyBitmap(); // Release some resources
+}
+else if (mContainer) {
+gtk_widget_hide(GTK_WIDGET(mContainer));
+}
+else if (mGdkWindow) {
+gdk_window_hide(mGdkWindow);
+}
+}
+}
+void
+nsWindow::SetHasMappedToplevel(bool aState)
+{
+// Even when aState == mHasMappedToplevel (as when this method is called
+// from Show()), child windows need to have their state checked, so don't
+// return early.
+bool oldState = mHasMappedToplevel;
+mHasMappedToplevel = aState;
+// mHasMappedToplevel is not updated for children of windows that are
+// hidden; GDK knows not to send expose events for these windows.  The
+// state is recorded on the hidden window itself, but, for child trees of
+// hidden windows, their state essentially becomes disconnected from their
+// hidden parent.  When the hidden parent gets shown, the child trees are
+// reconnected, and the state of the window being shown can be easily
+// propagated.
+if (!mIsShown || !mGdkWindow)
+return;
+if (aState && !oldState && !mIsFullyObscured) {
+// GDK_EXPOSE events have been ignored but the window is now visible,
+// so make sure GDK doesn't think that the window has already been
+// painted.
+gdk_window_invalidate_rect(mGdkWindow, nullptr, FALSE);
+// Check that a grab didn't fail due to the window not being
+// viewable.
+EnsureGrabs();
+}
+for (GList *children = gdk_window_peek_children(mGdkWindow);
+children;
+children = children->next) {
+GdkWindow *gdkWin = GDK_WINDOW(children->data);
+nsWindow *child = get_window_for_gdk_window(gdkWin);
+if (child && child->mHasMappedToplevel != aState) {
+child->SetHasMappedToplevel(aState);
+}
+}
+}
+nsIntSize
+nsWindow::GetSafeWindowSize(nsIntSize aSize)
+{
+// The X protocol uses CARD32 for window sizes, but the server (1.11.3)
+// reads it as CARD16.  Sizes of pixmaps, used for drawing, are (unsigned)
+// CARD16 in the protocol, but the server's ProcCreatePixmap returns
+// BadAlloc if dimensions cannot be represented by signed shorts.
+nsIntSize result = aSize;
+const int32_t kInt16Max = 32767;
+if (result.width > kInt16Max) {
+result.width = kInt16Max;
+}
+if (result.height > kInt16Max) {
+result.height = kInt16Max;
+}
+return result;
+}
+void
+nsWindow::EnsureGrabs(void)
+{
+if (mRetryPointerGrab)
+GrabPointer(sRetryGrabTime);
+}
+void
+nsWindow::CleanLayerManagerRecursive(void) {
+if (mLayerManager) {
+mLayerManager->Destroy();
+mLayerManager = nullptr;
+}
+DestroyCompositor();
+GList* children = gdk_window_peek_children(mGdkWindow);
+for (GList* list = children; list; list = list->next) {
+nsWindow* window = get_window_for_gdk_window(GDK_WINDOW(list->data));
+if (window) {
+window->CleanLayerManagerRecursive();
+}
+}
+}
+void
+nsWindow::SetTransparencyMode(nsTransparencyMode aMode)
+{
+if (!mShell) {
+// Pass the request to the toplevel window
+GtkWidget *topWidget = GetToplevelWidget();
+if (!topWidget)
+return;
+nsWindow *topWindow = get_window_for_gtk_widget(topWidget);
+if (!topWindow)
+return;
+topWindow->SetTransparencyMode(aMode);
+return;
+}
+bool isTransparent = aMode == eTransparencyTransparent;
+if (mIsTransparent == isTransparent)
+return;
+if (!isTransparent) {
+ClearTransparencyBitmap();
+} // else the new default alpha values are "all 1", so we don't
+// need to change anything yet
+mIsTransparent = isTransparent;
+// Need to clean our LayerManager up while still alive because
+// we don't want to use layers acceleration on shaped windows
+CleanLayerManagerRecursive();
+}
+nsTransparencyMode
+nsWindow::GetTransparencyMode()
+{
+if (!mShell) {
+// Pass the request to the toplevel window
+GtkWidget *topWidget = GetToplevelWidget();
+if (!topWidget) {
+return eTransparencyOpaque;
+}
+nsWindow *topWindow = get_window_for_gtk_widget(topWidget);
+if (!topWindow) {
+return eTransparencyOpaque;
+}
+return topWindow->GetTransparencyMode();
+}
+return mIsTransparent ? eTransparencyTransparent : eTransparencyOpaque;
+}
+nsresult
+nsWindow::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)
+{
+for (uint32_t i = 0; i < aConfigurations.Length(); ++i) {
+const Configuration& configuration = aConfigurations[i];
+nsWindow* w = static_cast<nsWindow*>(configuration.mChild);
+NS_ASSERTION(w->GetParent() == this,
+"Configured widget is not a child");
+w->SetWindowClipRegion(configuration.mClipRegion, true);
+if (w->mBounds.Size() != configuration.mBounds.Size()) {
+w->Resize(configuration.mBounds.x, configuration.mBounds.y,
+configuration.mBounds.width, configuration.mBounds.height,
+true);
+} else if (w->mBounds.TopLeft() != configuration.mBounds.TopLeft()) {
+w->Move(configuration.mBounds.x, configuration.mBounds.y);
+}
+w->SetWindowClipRegion(configuration.mClipRegion, false);
+}
+return NS_OK;
+}
+static pixman_box32
+ToPixmanBox(const nsIntRect& aRect)
+{
+pixman_box32_t result;
+result.x1 = aRect.x;
+result.y1 = aRect.y;
+result.x2 = aRect.XMost();
+result.y2 = aRect.YMost();
+return result;
+}
+static nsIntRect
+ToIntRect(const pixman_box32& aBox)
+{
+nsIntRect result;
+result.x = aBox.x1;
+result.y = aBox.y1;
+result.width = aBox.x2 - aBox.x1;
+result.height = aBox.y2 - aBox.y1;
+return result;
+}
+static void
+InitRegion(pixman_region32* aRegion,
+const nsTArray<nsIntRect>& aRects)
+{
+nsAutoTArray<pixman_box32,10> rects;
+rects.SetCapacity(aRects.Length());
+for (uint32_t i = 0; i < aRects.Length (); ++i) {
+if (!aRects[i].IsEmpty()) {
+rects.AppendElement(ToPixmanBox(aRects[i]));
+}
+}
+pixman_region32_init_rects(aRegion,
+rects.Elements(), rects.Length());
+}
+static void
+GetIntRects(pixman_region32& aRegion, nsTArray<nsIntRect>* aRects)
+{
+int nRects;
+pixman_box32* boxes = pixman_region32_rectangles(&aRegion, &nRects);
+aRects->SetCapacity(aRects->Length() + nRects);
+for (int i = 0; i < nRects; ++i) {
+aRects->AppendElement(ToIntRect(boxes[i]));
+}
+}
+void
+nsWindow::SetWindowClipRegion(const nsTArray<nsIntRect>& aRects,
+bool aIntersectWithExisting)
+{
+const nsTArray<nsIntRect>* newRects = &aRects;
+nsAutoTArray<nsIntRect,1> intersectRects;
+if (aIntersectWithExisting) {
+nsAutoTArray<nsIntRect,1> existingRects;
+GetWindowClipRegion(&existingRects);
+nsAutoRef<pixman_region32> existingRegion;
+InitRegion(&existingRegion, existingRects);
+nsAutoRef<pixman_region32> newRegion;
+InitRegion(&newRegion, aRects);
+nsAutoRef<pixman_region32> intersectRegion;
+pixman_region32_init(&intersectRegion);
+pixman_region32_intersect(&intersectRegion,
+&newRegion, &existingRegion);
+// If mClipRects is null we haven't set a clip rect yet, so we
+// need to set the clip even if it is equal.
+if (mClipRects &&
+pixman_region32_equal(&intersectRegion, &existingRegion)) {
+return;
+}
+if (!pixman_region32_equal(&intersectRegion, &newRegion)) {
+GetIntRects(intersectRegion, &intersectRects);
+newRects = &intersectRects;
+}
+}
+if (!StoreWindowClipRegion(*newRects))
+return;
+if (!mGdkWindow)
+return;
+#if (MOZ_WIDGET_GTK == 2)
+GdkRegion *region = gdk_region_new(); // aborts on OOM
+for (uint32_t i = 0; i < newRects->Length(); ++i) {
+const nsIntRect& r = newRects->ElementAt(i);
+GdkRectangle rect = { r.x, r.y, r.width, r.height };
+gdk_region_union_with_rect(region, &rect);
+}
+gdk_window_shape_combine_region(mGdkWindow, region, 0, 0);
+gdk_region_destroy(region);
+#else
+cairo_region_t *region = cairo_region_create();
+for (uint32_t i = 0; i < newRects->Length(); ++i) {
+const nsIntRect& r = newRects->ElementAt(i);
+cairo_rectangle_int_t rect = { r.x, r.y, r.width, r.height };
+cairo_region_union_rectangle(region, &rect);
+}
+gdk_window_shape_combine_region(mGdkWindow, region, 0, 0);
+cairo_region_destroy(region);
+#endif
+return;
+}
+void
+nsWindow::ResizeTransparencyBitmap()
+{
+if (!mTransparencyBitmap)
+return;
+if (mBounds.width == mTransparencyBitmapWidth &&
+mBounds.height == mTransparencyBitmapHeight)
+return;
+int32_t newRowBytes = GetBitmapStride(mBounds.width);
+int32_t newSize = newRowBytes * mBounds.height;
+gchar* newBits = new gchar[newSize];
+// fill new mask with "transparent", first
+memset(newBits, 0, newSize);
+// Now copy the intersection of the old and new areas into the new mask
+int32_t copyWidth = std::min(mBounds.width, mTransparencyBitmapWidth);
+int32_t copyHeight = std::min(mBounds.height, mTransparencyBitmapHeight);
+int32_t oldRowBytes = GetBitmapStride(mTransparencyBitmapWidth);
+int32_t copyBytes = GetBitmapStride(copyWidth);
+int32_t i;
+gchar* fromPtr = mTransparencyBitmap;
+gchar* toPtr = newBits;
+for (i = 0; i < copyHeight; i++) {
+memcpy(toPtr, fromPtr, copyBytes);
+fromPtr += oldRowBytes;
+toPtr += newRowBytes;
+}
+delete[] mTransparencyBitmap;
+mTransparencyBitmap = newBits;
+mTransparencyBitmapWidth = mBounds.width;
+mTransparencyBitmapHeight = mBounds.height;
+}
+static bool
+ChangedMaskBits(gchar* aMaskBits, int32_t aMaskWidth, int32_t aMaskHeight,
+const nsIntRect& aRect, uint8_t* aAlphas, int32_t aStride)
+{
+int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost();
+int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth);
+for (y = aRect.y; y < yMax; y++) {
+gchar* maskBytes = aMaskBits + y*maskBytesPerRow;
+uint8_t* alphas = aAlphas;
+for (x = aRect.x; x < xMax; x++) {
+bool newBit = *alphas > 0x7f;
+alphas++;
+gchar maskByte = maskBytes[x >> 3];
+bool maskBit = (maskByte & (1 << (x & 7))) != 0;
+if (maskBit != newBit) {
+return true;
+}
+}
+aAlphas += aStride;
+}
+return false;
+}
+static
+void UpdateMaskBits(gchar* aMaskBits, int32_t aMaskWidth, int32_t aMaskHeight,
+const nsIntRect& aRect, uint8_t* aAlphas, int32_t aStride)
+{
+int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost();
+int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth);
+for (y = aRect.y; y < yMax; y++) {
+gchar* maskBytes = aMaskBits + y*maskBytesPerRow;
+uint8_t* alphas = aAlphas;
+for (x = aRect.x; x < xMax; x++) {
+bool newBit = *alphas > 0x7f;
+alphas++;
+gchar mask = 1 << (x & 7);
+gchar maskByte = maskBytes[x >> 3];
+// Note: '-newBit' turns 0 into 00...00 and 1 into 11...11
+maskBytes[x >> 3] = (maskByte & ~mask) | (-newBit & mask);
+}
+aAlphas += aStride;
+}
+}
+void
+nsWindow::ApplyTransparencyBitmap()
+{
+#ifdef MOZ_X11
+// We use X11 calls where possible, because GDK handles expose events
+// for shaped windows in a way that's incompatible with us (Bug 635903).
+// It doesn't occur when the shapes are set through X.
+GdkWindow *shellWindow = gtk_widget_get_window(mShell);
+Display* xDisplay = GDK_WINDOW_XDISPLAY(shellWindow);
+Window xDrawable = GDK_WINDOW_XID(shellWindow);
+Pixmap maskPixmap = XCreateBitmapFromData(xDisplay,
+xDrawable,
+mTransparencyBitmap,
+mTransparencyBitmapWidth,
+mTransparencyBitmapHeight);
+XShapeCombineMask(xDisplay, xDrawable,
+ShapeBounding, 0, 0,
+maskPixmap, ShapeSet);
+XFreePixmap(xDisplay, maskPixmap);
+#else
+#if (MOZ_WIDGET_GTK == 2)
+gtk_widget_reset_shapes(mShell);
+GdkBitmap* maskBitmap = gdk_bitmap_create_from_data(gtk_widget_get_window(mShell),
+mTransparencyBitmap,
+mTransparencyBitmapWidth, mTransparencyBitmapHeight);
+if (!maskBitmap)
+return;
+gtk_widget_shape_combine_mask(mShell, maskBitmap, 0, 0);
+g_object_unref(maskBitmap);
+#else
+cairo_surface_t *maskBitmap;
+maskBitmap = cairo_image_surface_create_for_data((unsigned char*)mTransparencyBitmap,
+CAIRO_FORMAT_A1,
+mTransparencyBitmapWidth,
+mTransparencyBitmapHeight,
+GetBitmapStride(mTransparencyBitmapWidth));
+if (!maskBitmap)
+return;
+cairo_region_t * maskRegion = gdk_cairo_region_create_from_surface(maskBitmap);
+gtk_widget_shape_combine_region(mShell, maskRegion);
+cairo_region_destroy(maskRegion);
+cairo_surface_destroy(maskBitmap);
+#endif // MOZ_WIDGET_GTK2
+#endif // MOZ_X11
+}
+void
+nsWindow::ClearTransparencyBitmap()
+{
+if (!mTransparencyBitmap)
+return;
+delete[] mTransparencyBitmap;
+mTransparencyBitmap = nullptr;
+mTransparencyBitmapWidth = 0;
+mTransparencyBitmapHeight = 0;
+if (!mShell)
+return;
+#ifdef MOZ_X11
+GdkWindow *window = gtk_widget_get_window(mShell);
+if (!window)
+return;
+Display* xDisplay = GDK_WINDOW_XDISPLAY(window);
+Window xWindow = gdk_x11_window_get_xid(window);
+XShapeCombineMask(xDisplay, xWindow, ShapeBounding, 0, 0, None, ShapeSet);
+#endif
+}
+nsresult
+nsWindow::UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect,
+uint8_t* aAlphas, int32_t aStride)
+{
+if (!mShell) {
+// Pass the request to the toplevel window
+GtkWidget *topWidget = GetToplevelWidget();
+if (!topWidget)
+return NS_ERROR_FAILURE;
+nsWindow *topWindow = get_window_for_gtk_widget(topWidget);
+if (!topWindow)
+return NS_ERROR_FAILURE;
+return topWindow->UpdateTranslucentWindowAlphaInternal(aRect, aAlphas, aStride);
+}
+NS_ASSERTION(mIsTransparent, "Window is not transparent");
+if (mTransparencyBitmap == nullptr) {
+int32_t size = GetBitmapStride(mBounds.width)*mBounds.height;
+mTransparencyBitmap = new gchar[size];
+memset(mTransparencyBitmap, 255, size);
+mTransparencyBitmapWidth = mBounds.width;
+mTransparencyBitmapHeight = mBounds.height;
+} else {
+ResizeTransparencyBitmap();
+}
+nsIntRect rect;
+rect.IntersectRect(aRect, nsIntRect(0, 0, mBounds.width, mBounds.height));
+if (!ChangedMaskBits(mTransparencyBitmap, mBounds.width, mBounds.height,
+rect, aAlphas, aStride))
+// skip the expensive stuff if the mask bits haven't changed; hopefully
+// this is the common case
+return NS_OK;
+UpdateMaskBits(mTransparencyBitmap, mBounds.width, mBounds.height,
+rect, aAlphas, aStride);
+if (!mNeedsShow) {
+ApplyTransparencyBitmap();
+}
+return NS_OK;
+}
+void
+nsWindow::GrabPointer(guint32 aTime)
+{
+LOG(("GrabPointer time=0x%08x retry=%d\n",
+(unsigned int)aTime, mRetryPointerGrab));
+mRetryPointerGrab = false;
+sRetryGrabTime = aTime;
+// If the window isn't visible, just set the flag to retry the
+// grab.  When this window becomes visible, the grab will be
+// retried.
+if (!mHasMappedToplevel || mIsFullyObscured) {
+LOG(("GrabPointer: window not visible\n"));
+mRetryPointerGrab = true;
+return;
+}
+if (!mGdkWindow)
+return;
+gint retval;
+retval = gdk_pointer_grab(mGdkWindow, TRUE,
+(GdkEventMask)(GDK_BUTTON_PRESS_MASK |
+GDK_BUTTON_RELEASE_MASK |
+GDK_ENTER_NOTIFY_MASK |
+GDK_LEAVE_NOTIFY_MASK |
+GDK_POINTER_MOTION_MASK),
+(GdkWindow *)nullptr, nullptr, aTime);
+if (retval == GDK_GRAB_NOT_VIEWABLE) {
+LOG(("GrabPointer: window not viewable; will retry\n"));
+mRetryPointerGrab = true;
+} else if (retval != GDK_GRAB_SUCCESS) {
+LOG(("GrabPointer: pointer grab failed: %i\n", retval));
+// A failed grab indicates that another app has grabbed the pointer.
+// Check for rollup now, because, without the grab, we likely won't
+// get subsequent button press events.
+CheckForRollup(0, 0, false, true);
+}
+}
+void
+nsWindow::ReleaseGrabs(void)
+{
+LOG(("ReleaseGrabs\n"));
+mRetryPointerGrab = false;
+gdk_pointer_ungrab(GDK_CURRENT_TIME);
+}
+GtkWidget *
+nsWindow::GetToplevelWidget()
+{
+if (mShell) {
+return mShell;
+}
+GtkWidget *widget = GetMozContainerWidget();
+if (!widget)
+return nullptr;
+return gtk_widget_get_toplevel(widget);
+}
+GtkWidget *
+nsWindow::GetMozContainerWidget()
+{
+if (!mGdkWindow)
+return nullptr;
+if (mContainer)
+return GTK_WIDGET(mContainer);
+GtkWidget *owningWidget =
+get_gtk_widget_for_gdk_window(mGdkWindow);
+return owningWidget;
+}
+nsWindow *
+nsWindow::GetContainerWindow()
+{
+GtkWidget *owningWidget = GetMozContainerWidget();
+if (!owningWidget)
+return nullptr;
+nsWindow *window = get_window_for_gtk_widget(owningWidget);
+NS_ASSERTION(window, "No nsWindow for container widget");
+return window;
+}
+void
+nsWindow::SetUrgencyHint(GtkWidget *top_window, bool state)
+{
+if (!top_window)
+return;
+gdk_window_set_urgency_hint(gtk_widget_get_window(top_window), state);
+}
+void *
+nsWindow::SetupPluginPort(void)
+{
+if (!mGdkWindow)
+return nullptr;
+if (gdk_window_is_destroyed(mGdkWindow) == TRUE)
+return nullptr;
+Window window = gdk_x11_window_get_xid(mGdkWindow);
+// we have to flush the X queue here so that any plugins that
+// might be running on separate X connections will be able to use
+// this window in case it was just created
+#ifdef MOZ_X11
+XWindowAttributes xattrs;
+Display *display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+XGetWindowAttributes(display, window, &xattrs);
+XSelectInput (display, window,
+xattrs.your_event_mask |
+SubstructureNotifyMask);
+gdk_window_add_filter(mGdkWindow, plugin_window_filter_func, this);
+XSync(display, False);
+#endif /* MOZ_X11 */
+return (void *)window;
+}
+void
+nsWindow::SetDefaultIcon(void)
+{
+SetIcon(NS_LITERAL_STRING("default"));
+}
+void
+nsWindow::SetPluginType(PluginType aPluginType)
+{
+mPluginType = aPluginType;
+}
+#ifdef MOZ_X11
+void
+nsWindow::SetNonXEmbedPluginFocus()
+{
+if (gPluginFocusWindow == this || mPluginType!=PluginType_NONXEMBED) {
+return;
+}
+if (gPluginFocusWindow) {
+nsRefPtr<nsWindow> kungFuDeathGrip = gPluginFocusWindow;
+gPluginFocusWindow->LoseNonXEmbedPluginFocus();
+}
+LOGFOCUS(("nsWindow::SetNonXEmbedPluginFocus\n"));
+Window curFocusWindow;
+int focusState;
+GdkDisplay *gdkDisplay = gdk_window_get_display(mGdkWindow);
+XGetInputFocus(gdk_x11_display_get_xdisplay(gdkDisplay),
+&curFocusWindow,
+&focusState);
+LOGFOCUS(("\t curFocusWindow=%p\n", curFocusWindow));
+GdkWindow* toplevel = gdk_window_get_toplevel(mGdkWindow);
+#if (MOZ_WIDGET_GTK == 2)
+GdkWindow *gdkfocuswin = gdk_window_lookup(curFocusWindow);
+#else
+GdkWindow *gdkfocuswin = gdk_x11_window_lookup_for_display(gdkDisplay,
+curFocusWindow);
+#endif
+// lookup with the focus proxy window is supposed to get the
+// same GdkWindow as toplevel. If the current focused window
+// is not the focus proxy, we return without any change.
+if (gdkfocuswin != toplevel) {
+return;
+}
+// switch the focus from the focus proxy to the plugin window
+mOldFocusWindow = curFocusWindow;
+XRaiseWindow(GDK_WINDOW_XDISPLAY(mGdkWindow),
+gdk_x11_window_get_xid(mGdkWindow));
+gdk_error_trap_push();
+XSetInputFocus(GDK_WINDOW_XDISPLAY(mGdkWindow),
+gdk_x11_window_get_xid(mGdkWindow),
+RevertToNone,
+CurrentTime);
+gdk_flush();
+gdk_error_trap_pop();
+gPluginFocusWindow = this;
+gdk_window_add_filter(nullptr, plugin_client_message_filter, this);
+LOGFOCUS(("nsWindow::SetNonXEmbedPluginFocus oldfocus=%p new=%p\n",
+mOldFocusWindow, gdk_x11_window_get_xid(mGdkWindow)));
+}
+void
+nsWindow::LoseNonXEmbedPluginFocus()
+{
+LOGFOCUS(("nsWindow::LoseNonXEmbedPluginFocus\n"));
+// This method is only for the nsWindow which contains a
+// Non-XEmbed plugin, for example, JAVA plugin.
+if (gPluginFocusWindow != this || mPluginType!=PluginType_NONXEMBED) {
+return;
+}
+Window curFocusWindow;
+int focusState;
+XGetInputFocus(GDK_WINDOW_XDISPLAY(mGdkWindow),
+&curFocusWindow,
+&focusState);
+// we only switch focus between plugin window and focus proxy. If the
+// current focused window is not the plugin window, just removing the
+// event filter that blocks the WM_TAKE_FOCUS is enough. WM and gtk2
+// will take care of the focus later.
+if (!curFocusWindow ||
+curFocusWindow == gdk_x11_window_get_xid(mGdkWindow)) {
+gdk_error_trap_push();
+XRaiseWindow(GDK_WINDOW_XDISPLAY(mGdkWindow),
+mOldFocusWindow);
+XSetInputFocus(GDK_WINDOW_XDISPLAY(mGdkWindow),
+mOldFocusWindow,
+RevertToParent,
+CurrentTime);
+gdk_flush();
+gdk_error_trap_pop();
+}
+gPluginFocusWindow = nullptr;
+mOldFocusWindow = 0;
+gdk_window_remove_filter(nullptr, plugin_client_message_filter, this);
+LOGFOCUS(("nsWindow::LoseNonXEmbedPluginFocus end\n"));
+}
+#endif /* MOZ_X11 */
+gint
+nsWindow::ConvertBorderStyles(nsBorderStyle aStyle)
+{
+gint w = 0;
+if (aStyle == eBorderStyle_default)
+return -1;
+// note that we don't handle eBorderStyle_close yet
+if (aStyle & eBorderStyle_all)
+w |= GDK_DECOR_ALL;
+if (aStyle & eBorderStyle_border)
+w |= GDK_DECOR_BORDER;
+if (aStyle & eBorderStyle_resizeh)
+w |= GDK_DECOR_RESIZEH;
+if (aStyle & eBorderStyle_title)
+w |= GDK_DECOR_TITLE;
+if (aStyle & eBorderStyle_menu)
+w |= GDK_DECOR_MENU;
+if (aStyle & eBorderStyle_minimize)
+w |= GDK_DECOR_MINIMIZE;
+if (aStyle & eBorderStyle_maximize)
+w |= GDK_DECOR_MAXIMIZE;
+return w;
+}
+NS_IMETHODIMP
+nsWindow::MakeFullScreen(bool aFullScreen)
+{
+LOG(("nsWindow::MakeFullScreen [%p] aFullScreen %d\n",
+(void *)this, aFullScreen));
+if (aFullScreen) {
+if (mSizeMode != nsSizeMode_Fullscreen)
+mLastSizeMode = mSizeMode;
+mSizeMode = nsSizeMode_Fullscreen;
+gtk_window_fullscreen(GTK_WINDOW(mShell));
+}
+else {
+mSizeMode = mLastSizeMode;
+gtk_window_unfullscreen(GTK_WINDOW(mShell));
+}
+NS_ASSERTION(mLastSizeMode != nsSizeMode_Fullscreen,
+"mLastSizeMode should never be fullscreen");
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::HideWindowChrome(bool aShouldHide)
+{
+if (!mShell) {
+// Pass the request to the toplevel window
+GtkWidget *topWidget = GetToplevelWidget();
+if (!topWidget)
+return NS_ERROR_FAILURE;
+nsWindow *topWindow = get_window_for_gtk_widget(topWidget);
+if (!topWindow)
+return NS_ERROR_FAILURE;
+return topWindow->HideWindowChrome(aShouldHide);
+}
+// Sawfish, metacity, and presumably other window managers get
+// confused if we change the window decorations while the window
+// is visible.
+bool wasVisible = false;
+GdkWindow *shellWindow = gtk_widget_get_window(mShell);
+if (gdk_window_is_visible(shellWindow)) {
+gdk_window_hide(shellWindow);
+wasVisible = true;
+}
+gint wmd;
+if (aShouldHide)
+wmd = 0;
+else
+wmd = ConvertBorderStyles(mBorderStyle);
+if (wmd != -1)
+gdk_window_set_decorations(shellWindow, (GdkWMDecoration) wmd);
+if (wasVisible)
+gdk_window_show(shellWindow);
+// For some window managers, adding or removing window decorations
+// requires unmapping and remapping our toplevel window.  Go ahead
+// and flush the queue here so that we don't end up with a BadWindow
+// error later when this happens (when the persistence timer fires
+// and GetWindowPos is called)
+#ifdef MOZ_X11
+XSync(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()) , False);
+#else
+gdk_flush ();
+#endif /* MOZ_X11 */
+return NS_OK;
+}
+bool
+nsWindow::CheckForRollup(gdouble aMouseX, gdouble aMouseY,
+bool aIsWheel, bool aAlwaysRollup)
+{
+nsIRollupListener* rollupListener = GetActiveRollupListener();
+nsCOMPtr<nsIWidget> rollupWidget;
+if (rollupListener) {
+rollupWidget = rollupListener->GetRollupWidget();
+}
+if (!rollupWidget) {
+nsBaseWidget::gRollupListener = nullptr;
+return false;
+}
+bool retVal = false;
+GdkWindow *currentPopup =
+(GdkWindow *)rollupWidget->GetNativeData(NS_NATIVE_WINDOW);
+if (aAlwaysRollup || !is_mouse_in_window(currentPopup, aMouseX, aMouseY)) {
+bool rollup = true;
+if (aIsWheel) {
+rollup = rollupListener->ShouldRollupOnMouseWheelEvent();
+retVal = rollupListener->ShouldConsumeOnMouseWheelEvent();
+}
+// if we're dealing with menus, we probably have submenus and
+// we don't want to rollup if the click is in a parent menu of
+// the current submenu
+uint32_t popupsToRollup = UINT32_MAX;
+if (!aAlwaysRollup) {
+nsAutoTArray<nsIWidget*, 5> widgetChain;
+uint32_t sameTypeCount = rollupListener->GetSubmenuWidgetChain(&widgetChain);
+for (uint32_t i=0; i<widgetChain.Length(); ++i) {
+nsIWidget* widget = widgetChain[i];
+GdkWindow* currWindow =
+(GdkWindow*) widget->GetNativeData(NS_NATIVE_WINDOW);
+if (is_mouse_in_window(currWindow, aMouseX, aMouseY)) {
+// don't roll up if the mouse event occurred within a
+// menu of the same type. If the mouse event occurred
+// in a menu higher than that, roll up, but pass the
+// number of popups to Rollup so that only those of the
+// same type close up.
+if (i < sameTypeCount) {
+rollup = false;
+}
+else {
+popupsToRollup = sameTypeCount;
+}
+break;
+}
+} // foreach parent menu widget
+} // if rollup listener knows about menus
+// if we've determined that we should still rollup, do it.
+bool usePoint = !aIsWheel && !aAlwaysRollup;
+nsIntPoint point(aMouseX, aMouseY);
+if (rollup && rollupListener->Rollup(popupsToRollup, usePoint ? &point : nullptr, nullptr)) {
+retVal = true;
+}
+}
+return retVal;
+}
+/* static */
+bool
+nsWindow::DragInProgress(void)
+{
+nsCOMPtr<nsIDragService> dragService = do_GetService(kCDragServiceCID);
+if (!dragService)
+return false;
+nsCOMPtr<nsIDragSession> currentDragSession;
+dragService->GetCurrentSession(getter_AddRefs(currentDragSession));
+return currentDragSession != nullptr;
+}
+static bool
+is_mouse_in_window (GdkWindow* aWindow, gdouble aMouseX, gdouble aMouseY)
+{
+gint x = 0;
+gint y = 0;
+gint w, h;
+gint offsetX = 0;
+gint offsetY = 0;
+GdkWindow *window = aWindow;
+while (window) {
+gint tmpX = 0;
+gint tmpY = 0;
+gdk_window_get_position(window, &tmpX, &tmpY);
+GtkWidget *widget = get_gtk_widget_for_gdk_window(window);
+// if this is a window, compute x and y given its origin and our
+// offset
+if (GTK_IS_WINDOW(widget)) {
+x = tmpX + offsetX;
+y = tmpY + offsetY;
+break;
+}
+offsetX += tmpX;
+offsetY += tmpY;
+window = gdk_window_get_parent(window);
+}
+#if (MOZ_WIDGET_GTK == 2)
+gdk_drawable_get_size(aWindow, &w, &h);
+#else
+w = gdk_window_get_width(aWindow);
+h = gdk_window_get_height(aWindow);
+#endif
+if (aMouseX > x && aMouseX < x + w &&
+aMouseY > y && aMouseY < y + h)
+return true;
+return false;
+}
+static nsWindow *
+get_window_for_gtk_widget(GtkWidget *widget)
+{
+gpointer user_data = g_object_get_data(G_OBJECT(widget), "nsWindow");
+return static_cast<nsWindow *>(user_data);
+}
+static nsWindow *
+get_window_for_gdk_window(GdkWindow *window)
+{
+gpointer user_data = g_object_get_data(G_OBJECT(window), "nsWindow");
+return static_cast<nsWindow *>(user_data);
+}
+static GtkWidget *
+get_gtk_widget_for_gdk_window(GdkWindow *window)
+{
+gpointer user_data = nullptr;
+gdk_window_get_user_data(window, &user_data);
+return GTK_WIDGET(user_data);
+}
+static GdkCursor *
+get_gtk_cursor(nsCursor aCursor)
+{
+GdkCursor *gdkcursor = nullptr;
+uint8_t newType = 0xff;
+if ((gdkcursor = gCursorCache[aCursor])) {
+return gdkcursor;
+}
+GdkDisplay *defaultDisplay = gdk_display_get_default();
+// The strategy here is to use standard GDK cursors, and, if not available,
+// load by standard name with gdk_cursor_new_from_name.
+// Spec is here: http://www.freedesktop.org/wiki/Specifications/cursor-spec/
+switch (aCursor) {
+case eCursor_standard:
+gdkcursor = gdk_cursor_new(GDK_LEFT_PTR);
+break;
+case eCursor_wait:
+gdkcursor = gdk_cursor_new(GDK_WATCH);
+break;
+case eCursor_select:
+gdkcursor = gdk_cursor_new(GDK_XTERM);
+break;
+case eCursor_hyperlink:
+gdkcursor = gdk_cursor_new(GDK_HAND2);
+break;
+case eCursor_n_resize:
+gdkcursor = gdk_cursor_new(GDK_TOP_SIDE);
+break;
+case eCursor_s_resize:
+gdkcursor = gdk_cursor_new(GDK_BOTTOM_SIDE);
+break;
+case eCursor_w_resize:
+gdkcursor = gdk_cursor_new(GDK_LEFT_SIDE);
+break;
+case eCursor_e_resize:
+gdkcursor = gdk_cursor_new(GDK_RIGHT_SIDE);
+break;
+case eCursor_nw_resize:
+gdkcursor = gdk_cursor_new(GDK_TOP_LEFT_CORNER);
+break;
+case eCursor_se_resize:
+gdkcursor = gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER);
+break;
+case eCursor_ne_resize:
+gdkcursor = gdk_cursor_new(GDK_TOP_RIGHT_CORNER);
+break;
+case eCursor_sw_resize:
+gdkcursor = gdk_cursor_new(GDK_BOTTOM_LEFT_CORNER);
+break;
+case eCursor_crosshair:
+gdkcursor = gdk_cursor_new(GDK_CROSSHAIR);
+break;
+case eCursor_move:
+gdkcursor = gdk_cursor_new(GDK_FLEUR);
+break;
+case eCursor_help:
+gdkcursor = gdk_cursor_new(GDK_QUESTION_ARROW);
+break;
+case eCursor_copy: // CSS3
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "copy");
+if (!gdkcursor)
+newType = MOZ_CURSOR_COPY;
+break;
+case eCursor_alias:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "alias");
+if (!gdkcursor)
+newType = MOZ_CURSOR_ALIAS;
+break;
+case eCursor_context_menu:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "context-menu");
+if (!gdkcursor)
+newType = MOZ_CURSOR_CONTEXT_MENU;
+break;
+case eCursor_cell:
+gdkcursor = gdk_cursor_new(GDK_PLUS);
+break;
+// Those two aren’t standardized. Trying both KDE’s and GNOME’s names
+case eCursor_grab:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "openhand");
+if (!gdkcursor)
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "hand1");
+if (!gdkcursor)
+newType = MOZ_CURSOR_HAND_GRAB;
+break;
+case eCursor_grabbing:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "closedhand");
+if (!gdkcursor)
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "grabbing");
+if (!gdkcursor)
+newType = MOZ_CURSOR_HAND_GRABBING;
+break;
+case eCursor_spinning:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "progress");
+if (!gdkcursor)
+newType = MOZ_CURSOR_SPINNING;
+break;
+case eCursor_zoom_in:
+newType = MOZ_CURSOR_ZOOM_IN;
+break;
+case eCursor_zoom_out:
+newType = MOZ_CURSOR_ZOOM_OUT;
+break;
+case eCursor_not_allowed:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "not-allowed");
+if (!gdkcursor) // nonstandard, yet common
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "crossed_circle");
+if (!gdkcursor)
+newType = MOZ_CURSOR_NOT_ALLOWED;
+break;
+case eCursor_no_drop:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "no-drop");
+if (!gdkcursor) // this nonstandard sequence makes it work on KDE and GNOME
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "forbidden");
+if (!gdkcursor)
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "circle");
+if (!gdkcursor)
+newType = MOZ_CURSOR_NOT_ALLOWED;
+break;
+case eCursor_vertical_text:
+newType = MOZ_CURSOR_VERTICAL_TEXT;
+break;
+case eCursor_all_scroll:
+gdkcursor = gdk_cursor_new(GDK_FLEUR);
+break;
+case eCursor_nesw_resize:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "size_bdiag");
+if (!gdkcursor)
+newType = MOZ_CURSOR_NESW_RESIZE;
+break;
+case eCursor_nwse_resize:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "size_fdiag");
+if (!gdkcursor)
+newType = MOZ_CURSOR_NWSE_RESIZE;
+break;
+case eCursor_ns_resize:
+gdkcursor = gdk_cursor_new(GDK_SB_V_DOUBLE_ARROW);
+break;
+case eCursor_ew_resize:
+gdkcursor = gdk_cursor_new(GDK_SB_H_DOUBLE_ARROW);
+break;
+// Here, two better fitting cursors exist in some cursor themes. Try those first
+case eCursor_row_resize:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "split_v");
+if (!gdkcursor)
+gdkcursor = gdk_cursor_new(GDK_SB_V_DOUBLE_ARROW);
+break;
+case eCursor_col_resize:
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "split_h");
+if (!gdkcursor)
+gdkcursor = gdk_cursor_new(GDK_SB_H_DOUBLE_ARROW);
+break;
+case eCursor_none:
+newType = MOZ_CURSOR_NONE;
+break;
+default:
+NS_ASSERTION(aCursor, "Invalid cursor type");
+gdkcursor = gdk_cursor_new(GDK_LEFT_PTR);
+break;
+}
+// If by now we don't have a xcursor, this means we have to make a custom
+// one. First, we try creating a named cursor based on the hash of our
+// custom bitmap, as libXcursor has some magic to convert bitmapped cursors
+// to themed cursors
+if (newType != 0xFF && GtkCursors[newType].hash) {
+gdkcursor = gdk_cursor_new_from_name(defaultDisplay, GtkCursors[newType].hash);
+}
+// If we still don't have a xcursor, we now really create a bitmap cursor
+if (newType != 0xff && !gdkcursor) {
+GdkPixbuf * cursor_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 32, 32);
+if (!cursor_pixbuf)
+return nullptr;
+guchar *data = gdk_pixbuf_get_pixels(cursor_pixbuf);
+// Read data from GtkCursors and compose RGBA surface from 1bit bitmap and mask
+// GtkCursors bits and mask are 32x32 monochrome bitmaps (1 bit for each pixel)
+// so it's 128 byte array (4 bytes for are one bitmap row and there are 32 rows here).
+const unsigned char *bits = GtkCursors[newType].bits;
+const unsigned char *mask_bits = GtkCursors[newType].mask_bits;
+for (int i = 0; i < 128; i++) {
+char bit = *bits++;
+char mask = *mask_bits++;
+for (int j = 0; j < 8; j++) {
+unsigned char pix = ~(((bit >> j) & 0x01) * 0xff);
+*data++ = pix;
+*data++ = pix;
+*data++ = pix;
+*data++ = (((mask >> j) & 0x01) * 0xff);
+}
+}
+gdkcursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), cursor_pixbuf,
+GtkCursors[newType].hot_x,
+GtkCursors[newType].hot_y);
+g_object_unref(cursor_pixbuf);
+}
+gCursorCache[aCursor] = gdkcursor;
+return gdkcursor;
+}
+// gtk callbacks
+#if (MOZ_WIDGET_GTK == 2)
+static gboolean
+expose_event_cb(GtkWidget *widget, GdkEventExpose *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gdk_window(event->window);
+if (!window)
+return FALSE;
+window->OnExposeEvent(event);
+return FALSE;
+}
+#else
+void
+draw_window_of_widget(GtkWidget *widget, GdkWindow *aWindow, cairo_t *cr)
+{
+if (gtk_cairo_should_draw_window(cr, aWindow)) {
+nsRefPtr<nsWindow> window = get_window_for_gdk_window(aWindow);
+if (!window) {
+NS_WARNING("Cannot get nsWindow from GtkWidget");
+}
+else {
+cairo_save(cr);
+gtk_cairo_transform_to_window(cr, widget, aWindow);
+// TODO - window->OnExposeEvent() can destroy this or other windows,
+// do we need to handle it somehow?
+window->OnExposeEvent(cr);
+cairo_restore(cr);
+}
+}
+GList *children = gdk_window_get_children(aWindow);
+GList *child = children;
+while (child) {
+GdkWindow *window = GDK_WINDOW(child->data);
+gpointer windowWidget;
+gdk_window_get_user_data(window, &windowWidget);
+if (windowWidget == widget) {
+draw_window_of_widget(widget, window, cr);
+}
+child = g_list_next(child);
+}
+g_list_free(children);
+}
+/* static */
+gboolean
+expose_event_cb(GtkWidget *widget, cairo_t *cr)
+{
+draw_window_of_widget(widget, gtk_widget_get_window(widget), cr);
+return FALSE;
+}
+#endif //MOZ_WIDGET_GTK2
+static gboolean
+configure_event_cb(GtkWidget *widget,
+GdkEventConfigure *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+return window->OnConfigureEvent(widget, event);
+}
+static void
+container_unrealize_cb (GtkWidget *widget)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return;
+window->OnContainerUnrealize();
+}
+static void
+size_allocate_cb (GtkWidget *widget, GtkAllocation *allocation)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return;
+window->OnSizeAllocate(allocation);
+}
+static gboolean
+delete_event_cb(GtkWidget *widget, GdkEventAny *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+window->OnDeleteEvent();
+return TRUE;
+}
+static gboolean
+enter_notify_event_cb(GtkWidget *widget,
+GdkEventCrossing *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gdk_window(event->window);
+if (!window)
+return TRUE;
+window->OnEnterNotifyEvent(event);
+return TRUE;
+}
+static gboolean
+leave_notify_event_cb(GtkWidget *widget,
+GdkEventCrossing *event)
+{
+if (is_parent_grab_leave(event)) {
+return TRUE;
+}
+// bug 369599: Suppress LeaveNotify events caused by pointer grabs to
+// avoid generating spurious mouse exit events.
+gint x = gint(event->x_root);
+gint y = gint(event->y_root);
+GdkDisplay* display = gtk_widget_get_display(widget);
+GdkWindow* winAtPt = gdk_display_get_window_at_pointer(display, &x, &y);
+if (winAtPt == event->window) {
+return TRUE;
+}
+nsRefPtr<nsWindow> window = get_window_for_gdk_window(event->window);
+if (!window)
+return TRUE;
+window->OnLeaveNotifyEvent(event);
+return TRUE;
+}
+static nsWindow*
+GetFirstNSWindowForGDKWindow(GdkWindow *aGdkWindow)
+{
+nsWindow* window;
+while (!(window = get_window_for_gdk_window(aGdkWindow))) {
+// The event has bubbled to the moz_container widget as passed into each caller's *widget parameter,
+// but its corresponding nsWindow is an ancestor of the window that we need.  Instead, look at
+// event->window and find the first ancestor nsWindow of it because event->window may be in a plugin.
+aGdkWindow = gdk_window_get_parent(aGdkWindow);
+if (!aGdkWindow) {
+window = nullptr;
+break;
+}
+}
+return window;
+}
+static gboolean
+motion_notify_event_cb(GtkWidget *widget, GdkEventMotion *event)
+{
+UpdateLastInputEventTime(event);
+nsWindow *window = GetFirstNSWindowForGDKWindow(event->window);
+if (!window)
+return FALSE;
+window->OnMotionNotifyEvent(event);
+return TRUE;
+}
+static gboolean
+button_press_event_cb(GtkWidget *widget, GdkEventButton *event)
+{
+UpdateLastInputEventTime(event);
+nsWindow *window = GetFirstNSWindowForGDKWindow(event->window);
+if (!window)
+return FALSE;
+window->OnButtonPressEvent(event);
+return TRUE;
+}
+static gboolean
+button_release_event_cb(GtkWidget *widget, GdkEventButton *event)
+{
+UpdateLastInputEventTime(event);
+nsWindow *window = GetFirstNSWindowForGDKWindow(event->window);
+if (!window)
+return FALSE;
+window->OnButtonReleaseEvent(event);
+return TRUE;
+}
+static gboolean
+focus_in_event_cb(GtkWidget *widget, GdkEventFocus *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+window->OnContainerFocusInEvent(event);
+return FALSE;
+}
+static gboolean
+focus_out_event_cb(GtkWidget *widget, GdkEventFocus *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+window->OnContainerFocusOutEvent(event);
+return FALSE;
+}
+#ifdef MOZ_X11
+// For long-lived popup windows that don't really take focus themselves but
+// may have elements that accept keyboard input when the parent window is
+// active, focus is handled specially.  These windows include noautohide
+// panels.  (This special handling is not necessary for temporary popups where
+// the keyboard is grabbed.)
+//
+// Mousing over or clicking on these windows should not cause them to steal
+// focus from their parent windows, so, the input field of WM_HINTS is set to
+// False to request that the window manager not set the input focus to this
+// window.  http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.7
+//
+// However, these windows can still receive WM_TAKE_FOCUS messages from the
+// window manager, so they can still detect when the user has indicated that
+// they wish to direct keyboard input at these windows.  When the window
+// manager offers focus to these windows (after a mouse over or click, for
+// example), a request to make the parent window active is issued.  When the
+// parent window becomes active, keyboard events will be received.
+static GdkFilterReturn
+popup_take_focus_filter(GdkXEvent *gdk_xevent,
+GdkEvent *event,
+gpointer data)
+{
+XEvent* xevent = static_cast<XEvent*>(gdk_xevent);
+if (xevent->type != ClientMessage)
+return GDK_FILTER_CONTINUE;
+XClientMessageEvent& xclient = xevent->xclient;
+if (xclient.message_type != gdk_x11_get_xatom_by_name("WM_PROTOCOLS"))
+return GDK_FILTER_CONTINUE;
+Atom atom = xclient.data.l[0];
+if (atom != gdk_x11_get_xatom_by_name("WM_TAKE_FOCUS"))
+return GDK_FILTER_CONTINUE;
+guint32 timestamp = xclient.data.l[1];
+GtkWidget* widget = get_gtk_widget_for_gdk_window(event->any.window);
+if (!widget)
+return GDK_FILTER_CONTINUE;
+GtkWindow* parent = gtk_window_get_transient_for(GTK_WINDOW(widget));
+if (!parent)
+return GDK_FILTER_CONTINUE;
+if (gtk_window_is_active(parent))
+return GDK_FILTER_REMOVE; // leave input focus on the parent
+GdkWindow* parent_window = gtk_widget_get_window(GTK_WIDGET(parent));
+if (!parent_window)
+return GDK_FILTER_CONTINUE;
+// In case the parent has not been deconified.
+gdk_window_show_unraised(parent_window);
+// Request focus on the parent window.
+// Use gdk_window_focus rather than gtk_window_present to avoid
+// raising the parent window.
+gdk_window_focus(parent_window, timestamp);
+return GDK_FILTER_REMOVE;
+}
+static GdkFilterReturn
+plugin_window_filter_func(GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
+{
+GdkWindow  *plugin_window;
+XEvent     *xevent;
+Window      xeventWindow;
+nsRefPtr<nsWindow> nswindow = (nsWindow*)data;
+GdkFilterReturn return_val;
+xevent = (XEvent *)gdk_xevent;
+return_val = GDK_FILTER_CONTINUE;
+switch (xevent->type)
+{
+case CreateNotify:
+case ReparentNotify:
+if (xevent->type==CreateNotify) {
+xeventWindow = xevent->xcreatewindow.window;
+}
+else {
+if (xevent->xreparent.event != xevent->xreparent.parent)
+break;
+xeventWindow = xevent->xreparent.window;
+}
+#if (MOZ_WIDGET_GTK == 2)
+plugin_window = gdk_window_lookup(xeventWindow);
+#else
+plugin_window = gdk_x11_window_lookup_for_display(
+gdk_x11_lookup_xdisplay(xevent->xcreatewindow.display), xeventWindow);
+#endif
+if (plugin_window) {
+GtkWidget *widget =
+get_gtk_widget_for_gdk_window(plugin_window);
+// TODO GTK3
+#if (MOZ_WIDGET_GTK == 2)
+if (GTK_IS_XTBIN(widget)) {
+nswindow->SetPluginType(nsWindow::PluginType_NONXEMBED);
+break;
+}
+else
+#endif
+if(GTK_IS_SOCKET(widget)) {
+if (!g_object_get_data(G_OBJECT(widget), "enable-xt-focus")) {
+nswindow->SetPluginType(nsWindow::PluginType_XEMBED);
+break;
+}
+}
+}
+nswindow->SetPluginType(nsWindow::PluginType_NONXEMBED);
+return_val = GDK_FILTER_REMOVE;
+break;
+case EnterNotify:
+nswindow->SetNonXEmbedPluginFocus();
+break;
+case DestroyNotify:
+gdk_window_remove_filter
+((GdkWindow*)(nswindow->GetNativeData(NS_NATIVE_WINDOW)),
+plugin_window_filter_func,
+nswindow);
+// Currently we consider all plugins are non-xembed and calls
+// LoseNonXEmbedPluginFocus without any checking.
+nswindow->LoseNonXEmbedPluginFocus();
+break;
+default:
+break;
+}
+return return_val;
+}
+static GdkFilterReturn
+plugin_client_message_filter(GdkXEvent *gdk_xevent,
+GdkEvent *event,
+gpointer data)
+{
+XEvent    *xevent;
+xevent = (XEvent *)gdk_xevent;
+GdkFilterReturn return_val;
+return_val = GDK_FILTER_CONTINUE;
+if (!gPluginFocusWindow || xevent->type!=ClientMessage) {
+return return_val;
+}
+// When WM sends out WM_TAKE_FOCUS, gtk2 will use XSetInputFocus
+// to set the focus to the focus proxy. To prevent this happen
+// while the focus is on the plugin, we filter the WM_TAKE_FOCUS
+// out.
+if (gdk_x11_get_xatom_by_name("WM_PROTOCOLS")
+!= xevent->xclient.message_type) {
+return return_val;
+}
+if ((Atom) xevent->xclient.data.l[0] ==
+gdk_x11_get_xatom_by_name("WM_TAKE_FOCUS")) {
+// block it from gtk2.0 focus proxy
+return_val = GDK_FILTER_REMOVE;
+}
+return return_val;
+}
+#endif /* MOZ_X11 */
+static gboolean
+key_press_event_cb(GtkWidget *widget, GdkEventKey *event)
+{
+LOG(("key_press_event_cb\n"));
+UpdateLastInputEventTime(event);
+// find the window with focus and dispatch this event to that widget
+nsWindow *window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+nsRefPtr<nsWindow> focusWindow = gFocusWindow ? gFocusWindow : window;
+#ifdef MOZ_X11
+// Keyboard repeat can cause key press events to queue up when there are
+// slow event handlers (bug 301029).  Throttle these events by removing
+// consecutive pending duplicate KeyPress events to the same window.
+// We use the event time of the last one.
+// Note: GDK calls XkbSetDetectableAutorepeat so that KeyRelease events
+// are generated only when the key is physically released.
+#define NS_GDKEVENT_MATCH_MASK 0x1FFF /* GDK_SHIFT_MASK .. GDK_BUTTON5_MASK */
+GdkDisplay* gdkDisplay = gtk_widget_get_display(widget);
+Display* dpy = GDK_DISPLAY_XDISPLAY(gdkDisplay);
+while (XPending(dpy)) {
+XEvent next_event;
+XPeekEvent(dpy, &next_event);
+GdkWindow* nextGdkWindow =
+gdk_x11_window_lookup_for_display(gdkDisplay, next_event.xany.window);
+if (nextGdkWindow != event->window ||
+next_event.type != KeyPress ||
+next_event.xkey.keycode != event->hardware_keycode ||
+next_event.xkey.state != (event->state & NS_GDKEVENT_MATCH_MASK)) {
+break;
+}
+XNextEvent(dpy, &next_event);
+event->time = next_event.xkey.time;
+}
+#endif
+return focusWindow->OnKeyPressEvent(event);
+}
+static gboolean
+key_release_event_cb(GtkWidget *widget, GdkEventKey *event)
+{
+LOG(("key_release_event_cb\n"));
+UpdateLastInputEventTime(event);
+// find the window with focus and dispatch this event to that widget
+nsWindow *window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+nsRefPtr<nsWindow> focusWindow = gFocusWindow ? gFocusWindow : window;
+return focusWindow->OnKeyReleaseEvent(event);
+}
+static gboolean
+scroll_event_cb(GtkWidget *widget, GdkEventScroll *event)
+{
+nsWindow *window = GetFirstNSWindowForGDKWindow(event->window);
+if (!window)
+return FALSE;
+window->OnScrollEvent(event);
+return TRUE;
+}
+static gboolean
+visibility_notify_event_cb (GtkWidget *widget, GdkEventVisibility *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gdk_window(event->window);
+if (!window)
+return FALSE;
+window->OnVisibilityNotifyEvent(event);
+return TRUE;
+}
+static void
+hierarchy_changed_cb (GtkWidget *widget,
+GtkWidget *previous_toplevel)
+{
+GtkWidget *toplevel = gtk_widget_get_toplevel(widget);
+GdkWindowState old_window_state = GDK_WINDOW_STATE_WITHDRAWN;
+GdkEventWindowState event;
+event.new_window_state = GDK_WINDOW_STATE_WITHDRAWN;
+if (GTK_IS_WINDOW(previous_toplevel)) {
+g_signal_handlers_disconnect_by_func(previous_toplevel,
+FuncToGpointer(window_state_event_cb),
+widget);
+GdkWindow *win = gtk_widget_get_window(previous_toplevel);
+if (win) {
+old_window_state = gdk_window_get_state(win);
+}
+}
+if (GTK_IS_WINDOW(toplevel)) {
+g_signal_connect_swapped(toplevel, "window-state-event",
+G_CALLBACK(window_state_event_cb), widget);
+GdkWindow *win = gtk_widget_get_window(toplevel);
+if (win) {
+event.new_window_state = gdk_window_get_state(win);
+}
+}
+event.changed_mask = static_cast<GdkWindowState>
+(old_window_state ^ event.new_window_state);
+if (event.changed_mask) {
+event.type = GDK_WINDOW_STATE;
+event.window = nullptr;
+event.send_event = TRUE;
+window_state_event_cb(widget, &event);
+}
+}
+static gboolean
+window_state_event_cb (GtkWidget *widget, GdkEventWindowState *event)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(widget);
+if (!window)
+return FALSE;
+window->OnWindowStateEvent(widget, event);
+return FALSE;
+}
+static void
+theme_changed_cb (GtkSettings *settings, GParamSpec *pspec, nsWindow *data)
+{
+nsRefPtr<nsWindow> window = data;
+window->ThemeChanged();
+}
+//////////////////////////////////////////////////////////////////////
+// These are all of our drag and drop operations
+void
+nsWindow::InitDragEvent(WidgetDragEvent &aEvent)
+{
+// set the keyboard modifiers
+guint modifierState = KeymapWrapper::GetCurrentModifierState();
+KeymapWrapper::InitInputEvent(aEvent, modifierState);
+}
+static gboolean
+drag_motion_event_cb(GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+guint aTime,
+gpointer aData)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+if (!window)
+return FALSE;
+// figure out which internal widget this drag motion actually happened on
+nscoord retx = 0;
+nscoord rety = 0;
+GdkWindow *innerWindow =
+get_inner_gdk_window(gtk_widget_get_window(aWidget), aX, aY,
+&retx, &rety);
+nsRefPtr<nsWindow> innerMostWindow = get_window_for_gdk_window(innerWindow);
+if (!innerMostWindow) {
+innerMostWindow = window;
+}
+LOGDRAG(("nsWindow drag-motion signal for %p\n", (void*)innerMostWindow));
+return nsDragService::GetInstance()->
+ScheduleMotionEvent(innerMostWindow, aDragContext,
+nsIntPoint(retx, rety), aTime);
+}
+static void
+drag_leave_event_cb(GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+guint aTime,
+gpointer aData)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+if (!window)
+return;
+nsDragService *dragService = nsDragService::GetInstance();
+nsWindow *mostRecentDragWindow = dragService->GetMostRecentDestWindow();
+if (!mostRecentDragWindow) {
+// This can happen when the target will not accept a drop.  A GTK drag
+// source sends the leave message to the destination before the
+// drag-failed signal on the source widget, but the leave message goes
+// via the X server, and so doesn't get processed at least until the
+// event loop runs again.
+return;
+}
+GtkWidget *mozContainer = mostRecentDragWindow->GetMozContainerWidget();
+if (aWidget != mozContainer)
+{
+// When the drag moves between widgets, GTK can send leave signal for
+// the old widget after the motion or drop signal for the new widget.
+// We'll send the leave event when the motion or drop event is run.
+return;
+}
+LOGDRAG(("nsWindow drag-leave signal for %p\n",
+(void*)mostRecentDragWindow));
+dragService->ScheduleLeaveEvent();
+}
+static gboolean
+drag_drop_event_cb(GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+guint aTime,
+gpointer aData)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+if (!window)
+return FALSE;
+// figure out which internal widget this drag motion actually happened on
+nscoord retx = 0;
+nscoord rety = 0;
+GdkWindow *innerWindow =
+get_inner_gdk_window(gtk_widget_get_window(aWidget), aX, aY,
+&retx, &rety);
+nsRefPtr<nsWindow> innerMostWindow = get_window_for_gdk_window(innerWindow);
+if (!innerMostWindow) {
+innerMostWindow = window;
+}
+LOGDRAG(("nsWindow drag-drop signal for %p\n", (void*)innerMostWindow));
+return nsDragService::GetInstance()->
+ScheduleDropEvent(innerMostWindow, aDragContext,
+nsIntPoint(retx, rety), aTime);
+}
+static void
+drag_data_received_event_cb(GtkWidget *aWidget,
+GdkDragContext *aDragContext,
+gint aX,
+gint aY,
+GtkSelectionData  *aSelectionData,
+guint aInfo,
+guint aTime,
+gpointer aData)
+{
+nsRefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget);
+if (!window)
+return;
+window->OnDragDataReceivedEvent(aWidget,
+aDragContext,
+aX, aY,
+aSelectionData,
+aInfo, aTime, aData);
+}
+static nsresult
+initialize_prefs(void)
+{
+gRaiseWindows =
+Preferences::GetBool("mozilla.widget.raise-on-setfocus", true);
+return NS_OK;
+}
+static GdkWindow *
+get_inner_gdk_window (GdkWindow *aWindow,
+gint x, gint y,
+gint *retx, gint *rety)
+{
+gint cx, cy, cw, ch;
+GList *children = gdk_window_peek_children(aWindow);
+for (GList *child = g_list_last(children);
+child;
+child = g_list_previous(child)) {
+GdkWindow *childWindow = (GdkWindow *) child->data;
+if (get_window_for_gdk_window(childWindow)) {
+#if (MOZ_WIDGET_GTK == 2)
+gdk_window_get_geometry(childWindow, &cx, &cy, &cw, &ch, nullptr);
+#else
+gdk_window_get_geometry(childWindow, &cx, &cy, &cw, &ch);
+#endif
+if ((cx < x) && (x < (cx + cw)) &&
+(cy < y) && (y < (cy + ch)) &&
+gdk_window_is_visible(childWindow)) {
+return get_inner_gdk_window(childWindow,
+x - cx, y - cy,
+retx, rety);
+}
+}
+}
+*retx = x;
+*rety = y;
+return aWindow;
+}
+static inline bool
+is_context_menu_key(const WidgetKeyboardEvent& aKeyEvent)
+{
+return ((aKeyEvent.keyCode == NS_VK_F10 && aKeyEvent.IsShift() &&
+!aKeyEvent.IsControl() && !aKeyEvent.IsMeta() &&
+!aKeyEvent.IsAlt()) ||
+(aKeyEvent.keyCode == NS_VK_CONTEXT_MENU && !aKeyEvent.IsShift() &&
+!aKeyEvent.IsControl() && !aKeyEvent.IsMeta() &&
+!aKeyEvent.IsAlt()));
+}
+static int
+is_parent_ungrab_enter(GdkEventCrossing *aEvent)
+{
+return (GDK_CROSSING_UNGRAB == aEvent->mode) &&
+((GDK_NOTIFY_ANCESTOR == aEvent->detail) ||
+(GDK_NOTIFY_VIRTUAL == aEvent->detail));
+}
+static int
+is_parent_grab_leave(GdkEventCrossing *aEvent)
+{
+return (GDK_CROSSING_GRAB == aEvent->mode) &&
+((GDK_NOTIFY_ANCESTOR == aEvent->detail) ||
+(GDK_NOTIFY_VIRTUAL == aEvent->detail));
+}
+#ifdef ACCESSIBILITY
+void
+nsWindow::CreateRootAccessible()
+{
+if (mIsTopLevel && !mRootAccessible) {
+LOG(("nsWindow:: Create Toplevel Accessibility\n"));
+mRootAccessible = GetRootAccessible();
+}
+}
+void
+nsWindow::DispatchEventToRootAccessible(uint32_t aEventType)
+{
+if (!a11y::ShouldA11yBeEnabled()) {
+return;
+}
+nsCOMPtr<nsIAccessibilityService> accService =
+do_GetService("@mozilla.org/accessibilityService;1");
+if (!accService) {
+return;
+}
+// Get the root document accessible and fire event to it.
+a11y::Accessible* acc = GetRootAccessible();
+if (acc) {
+accService->FireAccessibleEvent(aEventType, acc);
+}
+}
+void
+nsWindow::DispatchActivateEventAccessible(void)
+{
+DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_ACTIVATE);
+}
+void
+nsWindow::DispatchDeactivateEventAccessible(void)
+{
+DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_DEACTIVATE);
+}
+void
+nsWindow::DispatchMaximizeEventAccessible(void)
+{
+DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_MAXIMIZE);
+}
+void
+nsWindow::DispatchMinimizeEventAccessible(void)
+{
+DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_MINIMIZE);
+}
+void
+nsWindow::DispatchRestoreEventAccessible(void)
+{
+DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_RESTORE);
+}
+#endif /* #ifdef ACCESSIBILITY */
+// nsChildWindow class
+nsChildWindow::nsChildWindow()
+{
+}
+nsChildWindow::~nsChildWindow()
+{
+}
+NS_IMETHODIMP
+nsWindow::NotifyIME(const IMENotification& aIMENotification)
+{
+if (MOZ_UNLIKELY(!mIMModule)) {
+switch (aIMENotification.mMessage) {
+case NOTIFY_IME_OF_CURSOR_POS_CHANGED:
+case REQUEST_TO_COMMIT_COMPOSITION:
+case REQUEST_TO_CANCEL_COMPOSITION:
+case NOTIFY_IME_OF_FOCUS:
+case NOTIFY_IME_OF_BLUR:
+return NS_ERROR_NOT_AVAILABLE;
+default:
+break;
+}
+}
+switch (aIMENotification.mMessage) {
+// TODO: We should replace NOTIFY_IME_OF_CURSOR_POS_CHANGED with
+//       NOTIFY_IME_OF_SELECTION_CHANGE.  The required behavior is
+//       really different from committing composition.
+case NOTIFY_IME_OF_CURSOR_POS_CHANGED:
+case REQUEST_TO_COMMIT_COMPOSITION:
+return mIMModule->CommitIMEComposition(this);
+case REQUEST_TO_CANCEL_COMPOSITION:
+return mIMModule->CancelIMEComposition(this);
+case NOTIFY_IME_OF_FOCUS:
+mIMModule->OnFocusChangeInGecko(true);
+return NS_OK;
+case NOTIFY_IME_OF_BLUR:
+mIMModule->OnFocusChangeInGecko(false);
+return NS_OK;
+case NOTIFY_IME_OF_COMPOSITION_UPDATE:
+mIMModule->OnUpdateComposition();
+return NS_OK;
+default:
+return NS_ERROR_NOT_IMPLEMENTED;
+}
+}
+NS_IMETHODIMP_(void)
+nsWindow::SetInputContext(const InputContext& aContext,
+const InputContextAction& aAction)
+{
+if (!mIMModule) {
+return;
+}
+mIMModule->SetInputContext(this, &aContext, &aAction);
+}
+NS_IMETHODIMP_(InputContext)
+nsWindow::GetInputContext()
+{
+InputContext context;
+if (!mIMModule) {
+context.mIMEState.mEnabled = IMEState::DISABLED;
+context.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED;
+// If IME context isn't available on this widget, we should set |this|
+// instead of nullptr since nullptr means that the platform has only one
+// context per process.
+context.mNativeIMEContext = this;
+} else {
+context = mIMModule->GetInputContext();
+context.mNativeIMEContext = mIMModule;
+}
+return context;
+}
+NS_IMETHODIMP_(bool)
+nsWindow::ExecuteNativeKeyBinding(NativeKeyBindingsType aType,
+const WidgetKeyboardEvent& aEvent,
+DoCommandCallback aCallback,
+void* aCallbackData)
+{
+NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType);
+return keyBindings->Execute(aEvent, aCallback, aCallbackData);
+}
+NS_IMETHODIMP
+nsWindow::GetToggledKeyState(uint32_t aKeyCode, bool* aLEDState)
+{
+NS_ENSURE_ARG_POINTER(aLEDState);
+KeymapWrapper::Modifiers modifier;
+switch (aKeyCode) {
+case NS_VK_CAPS_LOCK:   modifier = KeymapWrapper::CAPS_LOCK;   break;
+case NS_VK_NUM_LOCK:    modifier = KeymapWrapper::NUM_LOCK;    break;
+case NS_VK_SCROLL_LOCK: modifier = KeymapWrapper::SCROLL_LOCK; break;
+default: return NS_ERROR_INVALID_ARG;
+}
+*aLEDState =
+KeymapWrapper::AreModifiersCurrentlyActive(modifier);
+return NS_OK;
+}
+#if defined(MOZ_X11) && (MOZ_WIDGET_GTK == 2)
+/* static */ already_AddRefed<gfxASurface>
+nsWindow::GetSurfaceForGdkDrawable(GdkDrawable* aDrawable,
+const nsIntSize& aSize)
+{
+GdkVisual* visual = gdk_drawable_get_visual(aDrawable);
+Screen* xScreen =
+gdk_x11_screen_get_xscreen(gdk_drawable_get_screen(aDrawable));
+Display* xDisplay = DisplayOfScreen(xScreen);
+Drawable xDrawable = gdk_x11_drawable_get_xid(aDrawable);
+nsRefPtr<gfxASurface> result;
+if (visual) {
+Visual* xVisual = gdk_x11_visual_get_xvisual(visual);
+result = new gfxXlibSurface(xDisplay, xDrawable, xVisual,
+gfxIntSize(aSize.width, aSize.height));
+} else {
+// no visual? we must be using an xrender format.  Find a format
+// for this depth.
+XRenderPictFormat *pf = nullptr;
+switch (gdk_drawable_get_depth(aDrawable)) {
+case 32:
+pf = XRenderFindStandardFormat(xDisplay, PictStandardARGB32);
+break;
+case 24:
+pf = XRenderFindStandardFormat(xDisplay, PictStandardRGB24);
+break;
+default:
+NS_ERROR("Don't know how to handle the given depth!");
+break;
+}
+result = new gfxXlibSurface(xScreen, xDrawable, pf,
+gfxIntSize(aSize.width, aSize.height));
+}
+return result.forget();
+}
+#endif
+TemporaryRef<DrawTarget>
+nsWindow::StartRemoteDrawing()
+{
+#if (MOZ_WIDGET_GTK == 2)
+gfxASurface *surf = GetThebesSurface();
+#else
+// TODO GTK3
+gfxASurface *surf = nullptr;
+#endif
+if (!surf) {
+return nullptr;
+}
+IntSize size(surf->GetSize().width, surf->GetSize().height);
+if (size.width <= 0 || size.height <= 0) {
+return nullptr;
+}
+return gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(surf, size);
+}
+// return the gfxASurface for rendering to this widget
+gfxASurface*
+#if (MOZ_WIDGET_GTK == 2)
+nsWindow::GetThebesSurface()
+#else
+nsWindow::GetThebesSurface(cairo_t *cr)
+#endif
+{
+if (!mGdkWindow)
+return nullptr;
+#if (MOZ_WIDGET_GTK != 2)
+cairo_surface_t *surf = cairo_get_target(cr);
+if (cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS) {
+NS_NOTREACHED("Missing cairo target?");
+return nullptr;
+}
+#endif // MOZ_WIDGET_GTK2
+#ifdef MOZ_X11
+gint width, height;
+#if (MOZ_WIDGET_GTK == 2)
+gdk_drawable_get_size(GDK_DRAWABLE(mGdkWindow), &width, &height);
+#else
+width = gdk_window_get_width(mGdkWindow);
+height = gdk_window_get_height(mGdkWindow);
+#endif
+// Owen Taylor says this is the right thing to do!
+width = std::min(32767, width);
+height = std::min(32767, height);
+gfxIntSize size(width, height);
+GdkVisual *gdkVisual = gdk_window_get_visual(mGdkWindow);
+Visual* visual = gdk_x11_visual_get_xvisual(gdkVisual);
+#  ifdef MOZ_HAVE_SHMIMAGE
+bool usingShm = false;
+if (nsShmImage::UseShm()) {
+// EnsureShmImage() is a dangerous interface, but we guarantee
+// that the thebes surface and the shmimage have the same
+// lifetime
+mThebesSurface =
+nsShmImage::EnsureShmImage(size,
+visual, gdk_visual_get_depth(gdkVisual),
+mShmImage);
+usingShm = mThebesSurface != nullptr;
+}
+if (!usingShm)
+#  endif  // MOZ_HAVE_SHMIMAGE
+#if (MOZ_WIDGET_GTK == 2)
+mThebesSurface = new gfxXlibSurface
+(GDK_WINDOW_XDISPLAY(mGdkWindow),
+gdk_x11_window_get_xid(mGdkWindow),
+visual,
+size);
+#else
+#if MOZ_TREE_CAIRO
+#error "cairo-gtk3 target must be built with --enable-system-cairo"
+#else
+mThebesSurface = gfxASurface::Wrap(surf);
+#endif
+#endif
+#endif
+// if the surface creation is reporting an error, then
+// we don't have a surface to give back
+if (mThebesSurface && mThebesSurface->CairoStatus() != 0) {
+mThebesSurface = nullptr;
+}
+return mThebesSurface;
+}
+// Code shared begin BeginMoveDrag and BeginResizeDrag
+bool
+nsWindow::GetDragInfo(WidgetMouseEvent* aMouseEvent,
+GdkWindow** aWindow, gint* aButton,
+gint* aRootX, gint* aRootY)
+{
+if (aMouseEvent->button != WidgetMouseEvent::eLeftButton) {
+// we can only begin a move drag with the left mouse button
+return false;
+}
+*aButton = 1;
+// get the gdk window for this widget
+GdkWindow* gdk_window = mGdkWindow;
+if (!gdk_window) {
+return false;
+}
+NS_ABORT_IF_FALSE(GDK_IS_WINDOW(gdk_window), "must really be window");
+// find the top-level window
+gdk_window = gdk_window_get_toplevel(gdk_window);
+NS_ABORT_IF_FALSE(gdk_window,
+"gdk_window_get_toplevel should not return null");
+*aWindow = gdk_window;
+if (!aMouseEvent->widget) {
+return false;
+}
+// FIXME: It would be nice to have the widget position at the time
+// of the event, but it's relatively unlikely that the widget has
+// moved since the mousedown.  (On the other hand, it's quite likely
+// that the mouse has moved, which is why we use the mouse position
+// from the event.)
+nsIntPoint offset = aMouseEvent->widget->WidgetToScreenOffset();
+*aRootX = aMouseEvent->refPoint.x + offset.x;
+*aRootY = aMouseEvent->refPoint.y + offset.y;
+return true;
+}
+NS_IMETHODIMP
+nsWindow::BeginMoveDrag(WidgetMouseEvent* aEvent)
+{
+NS_ABORT_IF_FALSE(aEvent, "must have event");
+NS_ABORT_IF_FALSE(aEvent->eventStructType == NS_MOUSE_EVENT,
+"event must have correct struct type");
+GdkWindow *gdk_window;
+gint button, screenX, screenY;
+if (!GetDragInfo(aEvent, &gdk_window, &button, &screenX, &screenY)) {
+return NS_ERROR_FAILURE;
+}
+// tell the window manager to start the move
+gdk_window_begin_move_drag(gdk_window, button, screenX, screenY,
+aEvent->time);
+return NS_OK;
+}
+NS_IMETHODIMP
+nsWindow::BeginResizeDrag(WidgetGUIEvent* aEvent,
+int32_t aHorizontal,
+int32_t aVertical)
+{
+NS_ENSURE_ARG_POINTER(aEvent);
+if (aEvent->eventStructType != NS_MOUSE_EVENT) {
+// you can only begin a resize drag with a mouse event
+return NS_ERROR_INVALID_ARG;
+}
+GdkWindow *gdk_window;
+gint button, screenX, screenY;
+if (!GetDragInfo(aEvent->AsMouseEvent(), &gdk_window, &button,
+&screenX, &screenY)) {
+return NS_ERROR_FAILURE;
+}
+// work out what GdkWindowEdge we're talking about
+GdkWindowEdge window_edge;
+if (aVertical < 0) {
+if (aHorizontal < 0) {
+window_edge = GDK_WINDOW_EDGE_NORTH_WEST;
+} else if (aHorizontal == 0) {
+window_edge = GDK_WINDOW_EDGE_NORTH;
+} else {
+window_edge = GDK_WINDOW_EDGE_NORTH_EAST;
+}
+} else if (aVertical == 0) {
+if (aHorizontal < 0) {
+window_edge = GDK_WINDOW_EDGE_WEST;
+} else if (aHorizontal == 0) {
+return NS_ERROR_INVALID_ARG;
+} else {
+window_edge = GDK_WINDOW_EDGE_EAST;
+}
+} else {
+if (aHorizontal < 0) {
+window_edge = GDK_WINDOW_EDGE_SOUTH_WEST;
+} else if (aHorizontal == 0) {
+window_edge = GDK_WINDOW_EDGE_SOUTH;
+} else {
+window_edge = GDK_WINDOW_EDGE_SOUTH_EAST;
+}
+}
+// tell the window manager to start the resize
+gdk_window_begin_resize_drag(gdk_window, window_edge, button,
+screenX, screenY, aEvent->time);
+return NS_OK;
+}
+nsIWidget::LayerManager*
+nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
+LayersBackend aBackendHint,
+LayerManagerPersistence aPersistence,
+bool* aAllowRetaining)
+{
+if (!mLayerManager && eTransparencyTransparent == GetTransparencyMode()) {
+mLayerManager = CreateBasicLayerManager();
+}
+return nsBaseWidget::GetLayerManager(aShadowManager, aBackendHint,
+aPersistence, aAllowRetaining);
+}
+void
+nsWindow::ClearCachedResources()
+{
+if (mLayerManager &&
+mLayerManager->GetBackendType() == mozilla::layers::LayersBackend::LAYERS_BASIC) {
+mLayerManager->ClearCachedResources();
+}
+GList* children = gdk_window_peek_children(mGdkWindow);
+for (GList* list = children; list; list = list->next) {
+nsWindow* window = get_window_for_gdk_window(GDK_WINDOW(list->data));
+if (window) {
+window->ClearCachedResources();
+}
+}
+}
+nsresult
+nsWindow::SynthesizeNativeMouseEvent(nsIntPoint aPoint,
+uint32_t aNativeMessage,
+uint32_t aModifierFlags)
+{
+if (!mGdkWindow) {
+return NS_OK;
+}
+GdkDisplay* display = gdk_window_get_display(mGdkWindow);
+// When a button-release event is requested, create it here and put it in the
+// event queue. This will not emit a motion event - this needs to be done
+// explicitly *before* requesting a button-release. You will also need to wait
+// for the motion event to be dispatched before requesting a button-release
+// event to maintain the desired event order.
+if (aNativeMessage == GDK_BUTTON_RELEASE) {
+GdkEvent event;
+memset(&event, 0, sizeof(GdkEvent));
+event.type = (GdkEventType)aNativeMessage;
+event.button.button = 1;
+event.button.window = mGdkWindow;
+event.button.time = GDK_CURRENT_TIME;
+#if (MOZ_WIDGET_GTK == 3)
+// Get device for event source
+GdkDeviceManager *device_manager = gdk_display_get_device_manager(display);
+event.button.device = gdk_device_manager_get_client_pointer(device_manager);
+#endif
+gdk_event_put(&event);
+} else {
+// We don't support specific events other than button-release. In case
+// aNativeMessage != GDK_BUTTON_RELEASE we'll synthesize a motion event
+// that will be emitted by gdk_display_warp_pointer().
+GdkScreen* screen = gdk_window_get_screen(mGdkWindow);
+gdk_display_warp_pointer(display, screen, aPoint.x, aPoint.y);
+}
+return NS_OK;
+}

The Tor Browser / file comparison

comparison: widget/gtk/nsWindow.cpp

widget/gtk/nsWindow.cpp