diff -r 000000000000 -r 6474c204b198 dom/plugins/base/nsPluginNativeWindowGtk.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dom/plugins/base/nsPluginNativeWindowGtk.cpp Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,341 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=2:tabstop=2: +*/ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/** + * This file is the Gtk2 implementation of plugin native window. + */ + +#include "nsDebug.h" +#include "nsPluginNativeWindow.h" +#include "nsNPAPIPlugin.h" +#include "npapi.h" +#include +#include +#include + +#include "gtk2xtbin.h" +#include "mozilla/X11Util.h" + +class nsPluginNativeWindowGtk : public nsPluginNativeWindow { +public: + nsPluginNativeWindowGtk(); + virtual ~nsPluginNativeWindowGtk(); + + virtual nsresult CallSetWindow(nsRefPtr &aPluginInstance); +private: + void SetWindow(XID aWindow) + { + window = reinterpret_cast(static_cast(aWindow)); + } + XID GetWindow() const + { + return static_cast(reinterpret_cast(window)); + } + + NPSetWindowCallbackStruct mWsInfo; + /** + * Either a GtkSocket or a special GtkXtBin widget (derived from GtkSocket) + * that encapsulates the Xt toolkit within a Gtk Application. + */ + GtkWidget* mSocketWidget; + nsresult CreateXEmbedWindow(bool aEnableXtFocus); +#if (MOZ_WIDGET_GTK == 2) + nsresult CreateXtWindow(); +#endif + void SetAllocation(); +}; + +static gboolean plug_removed_cb (GtkWidget *widget, gpointer data); +static void socket_unrealize_cb (GtkWidget *widget, gpointer data); + +nsPluginNativeWindowGtk::nsPluginNativeWindowGtk() : nsPluginNativeWindow() +{ + // initialize the struct fields + window = nullptr; + x = 0; + y = 0; + width = 0; + height = 0; + memset(&clipRect, 0, sizeof(clipRect)); + ws_info = &mWsInfo; + type = NPWindowTypeWindow; + mSocketWidget = 0; + mWsInfo.type = 0; + mWsInfo.display = nullptr; + mWsInfo.visual = nullptr; + mWsInfo.colormap = 0; + mWsInfo.depth = 0; +} + +nsPluginNativeWindowGtk::~nsPluginNativeWindowGtk() +{ + if(mSocketWidget) { + gtk_widget_destroy(mSocketWidget); + } +} + +nsresult PLUG_NewPluginNativeWindow(nsPluginNativeWindow ** aPluginNativeWindow) +{ + NS_ENSURE_ARG_POINTER(aPluginNativeWindow); + *aPluginNativeWindow = new nsPluginNativeWindowGtk(); + return *aPluginNativeWindow ? NS_OK : NS_ERROR_OUT_OF_MEMORY; +} + +nsresult PLUG_DeletePluginNativeWindow(nsPluginNativeWindow * aPluginNativeWindow) +{ + NS_ENSURE_ARG_POINTER(aPluginNativeWindow); + nsPluginNativeWindowGtk *p = (nsPluginNativeWindowGtk *)aPluginNativeWindow; + delete p; + return NS_OK; +} + +nsresult nsPluginNativeWindowGtk::CallSetWindow(nsRefPtr &aPluginInstance) +{ + if (aPluginInstance) { + if (type == NPWindowTypeWindow) { + if (!mSocketWidget) { + nsresult rv; + + // The documentation on the types for many variables in NP(N|P)_GetValue + // is vague. Often boolean values are NPBool (1 byte), but + // https://developer.mozilla.org/en/XEmbed_Extension_for_Mozilla_Plugins + // treats NPPVpluginNeedsXEmbed as PRBool (int), and + // on x86/32-bit, flash stores to this using |movl 0x1,&needsXEmbed|. + // thus we can't use NPBool for needsXEmbed, or the three bytes above + // it on the stack would get clobbered. so protect with the larger bool. + int needsXEmbed = 0; + rv = aPluginInstance->GetValueFromPlugin(NPPVpluginNeedsXEmbed, &needsXEmbed); + // If the call returned an error code make sure we still use our default value. + if (NS_FAILED(rv)) { + needsXEmbed = 0; + } +#ifdef DEBUG + printf("nsPluginNativeWindowGtk: NPPVpluginNeedsXEmbed=%d\n", needsXEmbed); +#endif + + bool isOOPPlugin = aPluginInstance->GetPlugin()->GetLibrary()->IsOOP(); + if (needsXEmbed || isOOPPlugin) { + bool enableXtFocus = !needsXEmbed; + rv = CreateXEmbedWindow(enableXtFocus); + } + else { +#if (MOZ_WIDGET_GTK == 2) + rv = CreateXtWindow(); +#else + return NS_ERROR_FAILURE; +#endif + } + + if (NS_FAILED(rv)) { + return NS_ERROR_FAILURE; + } + } + + if (!mSocketWidget) { + return NS_ERROR_FAILURE; + } + + // Make sure to resize and re-place the window if required. + SetAllocation(); + // Need to reset "window" each time as nsObjectFrame::DidReflow sets it + // to the ancestor window. +#if (MOZ_WIDGET_GTK == 2) + if (GTK_IS_XTBIN(mSocketWidget)) { + // Point the NPWindow structures window to the actual X window + SetWindow(GTK_XTBIN(mSocketWidget)->xtwindow); + } + else { // XEmbed or OOP&Xt + SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget))); + } +#else + // Gtk3 supports only OOP by GtkSocket + SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget))); +#endif + +#ifdef DEBUG + printf("nsPluginNativeWindowGtk: call SetWindow with xid=%p\n", (void *)window); +#endif + } // NPWindowTypeWindow + aPluginInstance->SetWindow(this); + } + else if (mPluginInstance) + mPluginInstance->SetWindow(nullptr); + + SetPluginInstance(aPluginInstance); + return NS_OK; +} + +nsresult nsPluginNativeWindowGtk::CreateXEmbedWindow(bool aEnableXtFocus) { + NS_ASSERTION(!mSocketWidget,"Already created a socket widget!"); + GdkDisplay *display = gdk_display_get_default(); + GdkWindow *parent_win = gdk_x11_window_lookup_for_display(display, GetWindow()); + mSocketWidget = gtk_socket_new(); + + //attach the socket to the container widget + gtk_widget_set_parent_window(mSocketWidget, parent_win); + + // enable/disable focus event handlers, + // see plugin_window_filter_func() for details + g_object_set_data(G_OBJECT(mSocketWidget), "enable-xt-focus", (void *)aEnableXtFocus); + + // Make sure to handle the plug_removed signal. If we don't the + // socket will automatically be destroyed when the plug is + // removed, which means we're destroying it more than once. + // SYNTAX ERROR. + g_signal_connect(mSocketWidget, "plug_removed", + G_CALLBACK(plug_removed_cb), nullptr); + + g_signal_connect(mSocketWidget, "unrealize", + G_CALLBACK(socket_unrealize_cb), nullptr); + + g_signal_connect(mSocketWidget, "destroy", + G_CALLBACK(gtk_widget_destroyed), &mSocketWidget); + + gpointer user_data = nullptr; + gdk_window_get_user_data(parent_win, &user_data); + + GtkContainer *container = GTK_CONTAINER(user_data); + gtk_container_add(container, mSocketWidget); + gtk_widget_realize(mSocketWidget); + + // The GtkSocket has a visible window, but the plugin's XEmbed plug will + // cover this window. Normally GtkSockets let the X server paint their + // background and this would happen immediately (before the plug is + // created). Setting the background to None prevents the server from + // painting this window, avoiding flicker. + // TODO GTK3 +#if (MOZ_WIDGET_GTK == 2) + gdk_window_set_back_pixmap(gtk_widget_get_window(mSocketWidget), nullptr, FALSE); +#endif + + // Resize before we show + SetAllocation(); + + gtk_widget_show(mSocketWidget); + + gdk_flush(); + SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget))); + + // Fill out the ws_info structure. + // (The windowless case is done in nsObjectFrame.cpp.) + GdkWindow *gdkWindow = gdk_x11_window_lookup_for_display(display, GetWindow()); + if(!gdkWindow) + return NS_ERROR_FAILURE; + + mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow); +#if (MOZ_WIDGET_GTK == 2) + mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow)); + GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow); + mWsInfo.depth = gdkVisual->depth; +#else + mWsInfo.colormap = None; + GdkVisual* gdkVisual = gdk_window_get_visual(gdkWindow); + mWsInfo.depth = gdk_visual_get_depth(gdkVisual); +#endif + mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual); + + return NS_OK; +} + +void nsPluginNativeWindowGtk::SetAllocation() { + if (!mSocketWidget) + return; + + GtkAllocation new_allocation; + new_allocation.x = 0; + new_allocation.y = 0; + new_allocation.width = width; + new_allocation.height = height; + gtk_widget_size_allocate(mSocketWidget, &new_allocation); +} + +#if (MOZ_WIDGET_GTK == 2) +nsresult nsPluginNativeWindowGtk::CreateXtWindow() { + NS_ASSERTION(!mSocketWidget,"Already created a socket widget!"); + +#ifdef DEBUG + printf("About to create new xtbin of %i X %i from %p...\n", + width, height, (void*)window); +#endif + GdkDisplay *display = gdk_display_get_default(); + GdkWindow *gdkWindow = gdk_x11_window_lookup_for_display(display, GetWindow()); + mSocketWidget = gtk_xtbin_new(gdkWindow, 0); + // Check to see if creating the xtbin failed for some reason. + // if it did, we can't go any further. + if (!mSocketWidget) + return NS_ERROR_FAILURE; + + g_signal_connect(mSocketWidget, "destroy", + G_CALLBACK(gtk_widget_destroyed), &mSocketWidget); + + gtk_widget_set_size_request(mSocketWidget, width, height); + +#ifdef DEBUG + printf("About to show xtbin(%p)...\n", (void*)mSocketWidget); fflush(nullptr); +#endif + gtk_widget_show(mSocketWidget); +#ifdef DEBUG + printf("completed gtk_widget_show(%p)\n", (void*)mSocketWidget); fflush(nullptr); +#endif + + // Fill out the ws_info structure. + GtkXtBin* xtbin = GTK_XTBIN(mSocketWidget); + // The xtbin has its own Display structure. + mWsInfo.display = xtbin->xtdisplay; + mWsInfo.colormap = xtbin->xtclient.xtcolormap; + mWsInfo.visual = xtbin->xtclient.xtvisual; + mWsInfo.depth = xtbin->xtclient.xtdepth; + // Leave mWsInfo.type = 0 - Who knows what this is meant to be? + + XFlush(mWsInfo.display); + + return NS_OK; +} +#endif + +/* static */ +gboolean +plug_removed_cb (GtkWidget *widget, gpointer data) +{ + // Gee, thanks for the info! + return TRUE; +} + +static void +socket_unrealize_cb(GtkWidget *widget, gpointer data) +{ + // Unmap and reparent any child windows that GDK does not yet know about. + // (See bug 540114 comment 10.) + GdkWindow* socket_window = gtk_widget_get_window(widget); + GdkDisplay* gdkDisplay = gdk_display_get_default(); + Display* display = GDK_DISPLAY_XDISPLAY(gdkDisplay); + + // Ignore X errors that may happen if windows get destroyed (possibly + // requested by the plugin) between XQueryTree and when we operate on them. + gdk_error_trap_push(); + + Window root, parent; + Window* children; + unsigned int nchildren; + if (!XQueryTree(display, gdk_x11_window_get_xid(socket_window), + &root, &parent, &children, &nchildren)) + return; + + for (unsigned int i = 0; i < nchildren; ++i) { + Window child = children[i]; + if (!gdk_x11_window_lookup_for_display(gdkDisplay, child)) { + // This window is not known to GDK. + XUnmapWindow(display, child); + XReparentWindow(display, child, DefaultRootWindow(display), 0, 0); + } + } + + if (children) XFree(children); + + mozilla::FinishX(display); + gdk_error_trap_pop(); +}