AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

gtk/gtksocket-stub.c gtk/gtkplug-stub.c gtk/gtksocket-x11.c

Browse Source 
2005-07-21  Tor Lillqvist  <tml@novell.com>

	* gtk/gtksocket-stub.c
	* gtk/gtkplug-stub.c
	* gtk/gtksocket-x11.c
	* gtk/gtkplug-x11.c
	* gtk/gtksocket-win32.c
	* gtk/gtkplug-win32.c
	* gtk/gtkwin32embed.h
	* gtk/gtkwin32embed.c: New files, containing the backend-specific
	parts of GtkPlug/Socket.
This commit is contained in:
Tor Lillqvist 2005-07-21 13:26:27 +00:00 committed by Tor Lillqvist
parent 2e96cb67ce
commit 27940c430e
11 changed files with 2013 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ChangeLog
View File

@ -1,5 +1,15 @@
2005-07-21 Tor Lillqvist <tml@novell.com>
* gtk/gtksocket-stub.c
* gtk/gtkplug-stub.c
* gtk/gtksocket-x11.c
* gtk/gtkplug-x11.c
* gtk/gtksocket-win32.c
* gtk/gtkplug-win32.c
* gtk/gtkwin32embed.h
* gtk/gtkwin32embed.c: New files, containing the backend-specific
parts of GtkPlug/Socket.
* gtk/gtkxembed.h
* gtk/gtkxembed.c (_gtk_xembed_message_name): New function, used
in error messages and debugging output.

10
ChangeLog.pre-2-10
View File

@ -1,5 +1,15 @@
2005-07-21 Tor Lillqvist <tml@novell.com>
* gtk/gtksocket-stub.c
* gtk/gtkplug-stub.c
* gtk/gtksocket-x11.c
* gtk/gtkplug-x11.c
* gtk/gtksocket-win32.c
* gtk/gtkplug-win32.c
* gtk/gtkwin32embed.h
* gtk/gtkwin32embed.c: New files, containing the backend-specific
parts of GtkPlug/Socket.
* gtk/gtkxembed.h
* gtk/gtkxembed.c (_gtk_xembed_message_name): New function, used
in error messages and debugging output.

10
ChangeLog.pre-2-8
View File

@ -1,5 +1,15 @@
2005-07-21 Tor Lillqvist <tml@novell.com>
* gtk/gtksocket-stub.c
* gtk/gtkplug-stub.c
* gtk/gtksocket-x11.c
* gtk/gtkplug-x11.c
* gtk/gtksocket-win32.c
* gtk/gtkplug-win32.c
* gtk/gtkwin32embed.h
* gtk/gtkwin32embed.c: New files, containing the backend-specific
parts of GtkPlug/Socket.
* gtk/gtkxembed.h
* gtk/gtkxembed.c (_gtk_xembed_message_name): New function, used
in error messages and debugging output.

82
gtk/gtkplug-stub.c Normal file
View File

@ -0,0 +1,82 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Stub implementation of backend-specific GtkPlug functions. */
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "gtkplugprivate.h"
GdkNativeWindow
_gtk_plug_windowing_get_id (GtkPlug *plug)
{
return 0;
}
void
_gtk_plug_windowing_realize_toplevel (GtkPlug *plug)
{
}
void
_gtk_plug_windowing_map_toplevel (GtkPlug *plug)
{
}
void
_gtk_plug_windowing_unmap_toplevel (GtkPlug *plug)
{
}
void
_gtk_plug_windowing_set_focus (GtkPlug *plug)
{
}
void
_gtk_plug_windowing_add_grabbed_key (GtkPlug *plug,
guint accelerator_key,
GdkModifierType accelerator_mods)
{
}
void
_gtk_plug_windowing_remove_grabbed_key (GtkPlug *plug,
guint accelerator_key,
GdkModifierType accelerator_mods)
{
}
void
_gtk_plug_windowing_focus_to_parent (GtkPlug *plug,
GtkDirectionType direction)
{
}
GdkFilterReturn
_gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
return GDK_FILTER_CONTINUE;
}

299
gtk/gtkplug-win32.c Normal file
View File

@ -0,0 +1,299 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 2005 Novell, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* By Tor Lillqvist <tml@novell.com> 2005 */
/*
* Modified by the GTK+ Team and others 1997-2005. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "gtkmarshalers.h"
#include "gtkplug.h"
#include "gtkplugprivate.h"
#include "win32/gdkwin32.h"
#include "gtkwin32embed.h"
GdkNativeWindow
_gtk_plug_windowing_get_id (GtkPlug *plug)
{
return (GdkNativeWindow) GDK_WINDOW_HWND (GTK_WIDGET (plug)->window);
}
void
_gtk_plug_windowing_realize_toplevel (GtkPlug *plug)
{
if (plug->socket_window)
{
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_PARENT_NOTIFY,
(int) GDK_WINDOW_HWND (GTK_WIDGET (plug)->window),
GTK_WIN32_EMBED_PROTOCOL_VERSION);
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_EVENT_PLUG_MAPPED, 0, 0);
}
}
void
_gtk_plug_windowing_map_toplevel (GtkPlug *plug)
{
if (plug->socket_window)
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,
1, 0);
}
void
_gtk_plug_windowing_unmap_toplevel (GtkPlug *plug)
{
if (plug->socket_window)
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,
0, 0);
}
void
_gtk_plug_windowing_set_focus (GtkPlug *plug)
{
if (plug->socket_window)
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_REQUEST_FOCUS,
0, 0);
}
void
_gtk_plug_windowing_add_grabbed_key (GtkPlug *plug,
guint accelerator_key,
GdkModifierType accelerator_mods)
{
if (plug->socket_window)
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_GRAB_KEY,
accelerator_key, accelerator_mods);
}
void
_gtk_plug_windowing_remove_grabbed_key (GtkPlug *plug,
guint accelerator_key,
GdkModifierType accelerator_mods)
{
if (plug->socket_window)
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_UNGRAB_KEY,
accelerator_key, accelerator_mods);
}
void
_gtk_plug_windowing_focus_to_parent (GtkPlug *plug,
GtkDirectionType direction)
{
GtkWin32EmbedMessageType message = GTK_WIN32_EMBED_FOCUS_PREV;
switch (direction)
{
case GTK_DIR_UP:
case GTK_DIR_LEFT:
case GTK_DIR_TAB_BACKWARD:
message = GTK_WIN32_EMBED_FOCUS_PREV;
break;
case GTK_DIR_DOWN:
case GTK_DIR_RIGHT:
case GTK_DIR_TAB_FORWARD:
message = GTK_WIN32_EMBED_FOCUS_NEXT;
break;
}
_gtk_win32_embed_send_focus_message (plug->socket_window, message, 0);
}
GdkFilterReturn
_gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
GtkPlug *plug = GTK_PLUG (data);
MSG *msg = (MSG *) gdk_xevent;
GdkFilterReturn return_val = GDK_FILTER_CONTINUE;
switch (msg->message)
{
/* What message should we look for to notice the reparenting?
* Maybe WM_WINDOWPOSCHANGED will work? This is handled in the
* X11 implementation by handling ReparentNotify. Handle this
* only for cross-process embedding, otherwise we get odd
* crashes in testsocket.
*/
case WM_WINDOWPOSCHANGED:
if (!plug->same_app)
{
HWND parent = GetAncestor (msg->hwnd, GA_PARENT);
gboolean was_embedded = plug->socket_window != NULL;
GdkScreen *screen = gdk_drawable_get_screen (event->any.window);
GdkDisplay *display = gdk_screen_get_display (screen);
GTK_NOTE (PLUGSOCKET, g_printerr ("WM_WINDOWPOSCHANGED: hwnd=%p GA_PARENT=%p socket_window=%p\n", msg->hwnd, parent, plug->socket_window));
g_object_ref (plug);
if (was_embedded)
{
/* End of embedding protocol for previous socket */
if (parent != GDK_WINDOW_HWND (plug->socket_window))
{
GtkWidget *widget = GTK_WIDGET (plug);
GTK_NOTE (PLUGSOCKET, g_printerr ("was_embedded, current parent != socket_window\n"));
gdk_window_set_user_data (plug->socket_window, NULL);
g_object_unref (plug->socket_window);
plug->socket_window = NULL;
/* Emit a delete window, as if the user attempted to
* close the toplevel. Only do this if we are being
* reparented to the desktop window. Moving from one
* embedder to another should be invisible to the app.
*/
if (parent == GetDesktopWindow ())
{
GTK_NOTE (PLUGSOCKET, g_printerr ("current parent is root window\n"));
_gtk_plug_send_delete_event (widget);
return_val = GDK_FILTER_REMOVE;
}
}
else
{
GTK_NOTE (PLUGSOCKET, g_printerr ("still same parent\n"));
goto done;
}
}
if (parent != GetDesktopWindow ())
{
/* Start of embedding protocol */
GTK_NOTE (PLUGSOCKET, g_printerr ("start of embedding\n"));
plug->socket_window = gdk_window_lookup_for_display (display, (GdkNativeWindow) parent);
if (plug->socket_window)
{
gpointer user_data = NULL;
GTK_NOTE (PLUGSOCKET, g_printerr ("already had socket_window\n"));
gdk_window_get_user_data (plug->socket_window, &user_data);
if (user_data)
{
g_warning (G_STRLOC "Plug reparented unexpectedly into window in the same process");
plug->socket_window = NULL;
break;
}
g_object_ref (plug->socket_window);
}
else
{
plug->socket_window = gdk_window_foreign_new_for_display (display, (GdkNativeWindow) parent);
if (!plug->socket_window) /* Already gone */
break;
}
_gtk_plug_add_all_grabbed_keys (plug);
if (!was_embedded)
g_signal_emit_by_name (plug, "embedded");
}
done:
g_object_unref (plug);
}
break;
case WM_SIZE:
if (!plug->same_app && plug->socket_window)
{
_gtk_win32_embed_send (plug->socket_window,
GTK_WIN32_EMBED_PLUG_RESIZED,
0, 0);
}
break;
default:
if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_WINDOW_ACTIVATE))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: WINDOW_ACTIVATE received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_window_set_is_active (GTK_WINDOW (plug), TRUE);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_WINDOW_DEACTIVATE))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: WINDOW_DEACTIVATE received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_window_set_is_active (GTK_WINDOW (plug), FALSE);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_IN))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: FOCUS_IN received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_window_set_has_toplevel_focus (GTK_WINDOW (plug), TRUE);
switch (msg->wParam)
{
case GTK_WIN32_EMBED_FOCUS_CURRENT:
break;
case GTK_WIN32_EMBED_FOCUS_FIRST:
_gtk_plug_focus_first_last (plug, GTK_DIR_TAB_FORWARD);
break;
case GTK_WIN32_EMBED_FOCUS_LAST:
_gtk_plug_focus_first_last (plug, GTK_DIR_TAB_BACKWARD);
break;
}
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_OUT))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: FOCUS_OUT received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_window_set_has_toplevel_focus (GTK_WINDOW (plug), FALSE);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_MODALITY_ON))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: MODALITY_ON received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_plug_handle_modality_on (plug);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_MODALITY_OFF))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: MODALITY_OFF received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_plug_handle_modality_off (plug);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
break;
}
return return_val;
}

328
gtk/gtkplug-x11.c Normal file
View File

@ -0,0 +1,328 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* By Owen Taylor <otaylor@gtk.org> 98/4/4 */
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "gtkalias.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkplug.h"
#include "gtkprivate.h"
#include "gtkplugprivate.h"
#include "x11/gdkx.h"
#include "gtkxembed.h"
static void xembed_set_info (GdkWindow *window,
unsigned long flags);
GdkNativeWindow
_gtk_plug_windowing_get_id (GtkPlug *plug)
{
return GDK_WINDOW_XWINDOW (GTK_WIDGET (plug)->window);
}
void
_gtk_plug_windowing_realize_toplevel (GtkPlug *plug)
{
xembed_set_info (GTK_WIDGET (plug)->window, 0);
}
void
_gtk_plug_windowing_map_toplevel (GtkPlug *plug)
{
xembed_set_info (GTK_WIDGET (plug)->window, XEMBED_MAPPED);
}
void
_gtk_plug_windowing_unmap_toplevel (GtkPlug *plug)
{
xembed_set_info (GTK_WIDGET (plug)->window, 0);
}
void
_gtk_plug_windowing_set_focus (GtkPlug *plug)
{
_gtk_xembed_send_message (plug->socket_window,
XEMBED_REQUEST_FOCUS, 0, 0, 0);
}
void
_gtk_plug_windowing_add_grabbed_key (GtkPlug *plug,
guint accelerator_key,
GdkModifierType accelerator_mods)
{
_gtk_xembed_send_message (plug->socket_window, XEMBED_GTK_GRAB_KEY, 0,
accelerator_key, accelerator_mods);
}
void
_gtk_plug_windowing_remove_grabbed_key (GtkPlug *plug,
guint accelerator_key,
GdkModifierType accelerator_mods)
{
_gtk_xembed_send_message (plug->socket_window, XEMBED_GTK_UNGRAB_KEY, 0,
accelerator_key, accelerator_mods);
}
void
_gtk_plug_windowing_focus_to_parent (GtkPlug *plug,
GtkDirectionType direction)
{
XEmbedMessageType message = XEMBED_FOCUS_PREV; /* Quiet GCC */
switch (direction)
{
case GTK_DIR_UP:
case GTK_DIR_LEFT:
case GTK_DIR_TAB_BACKWARD:
message = XEMBED_FOCUS_PREV;
break;
case GTK_DIR_DOWN:
case GTK_DIR_RIGHT:
case GTK_DIR_TAB_FORWARD:
message = XEMBED_FOCUS_NEXT;
break;
}
_gtk_xembed_send_focus_message (plug->socket_window, message, 0);
}
static void
xembed_set_info (GdkWindow *window,
unsigned long flags)
{
GdkDisplay *display = gdk_drawable_get_display (window);
unsigned long buffer[2];
Atom xembed_info_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO");
buffer[0] = GTK_XEMBED_PROTOCOL_VERSION;
buffer[1] = flags;
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XWINDOW (window),
xembed_info_atom, xembed_info_atom, 32,
PropModeReplace,
(unsigned char *)buffer, 2);
}
static void
handle_xembed_message (GtkPlug *plug,
XEmbedMessageType message,
glong detail,
glong data1,
glong data2,
guint32 time)
{
GtkWindow *window = GTK_WINDOW (plug);
GTK_NOTE (PLUGSOCKET,
g_message ("GtkPlug: %s received", _gtk_xembed_message_name (message)));
switch (message)
{
case XEMBED_EMBEDDED_NOTIFY:
break;
case XEMBED_WINDOW_ACTIVATE:
_gtk_window_set_is_active (window, TRUE);
break;
case XEMBED_WINDOW_DEACTIVATE:
_gtk_window_set_is_active (window, FALSE);
break;
case XEMBED_MODALITY_ON:
_gtk_plug_handle_modality_on (plug);
break;
case XEMBED_MODALITY_OFF:
_gtk_plug_handle_modality_off (plug);
break;
case XEMBED_FOCUS_IN:
_gtk_window_set_has_toplevel_focus (window, TRUE);
switch (detail)
{
case XEMBED_FOCUS_FIRST:
_gtk_plug_focus_first_last (plug, GTK_DIR_TAB_FORWARD);
break;
case XEMBED_FOCUS_LAST:
_gtk_plug_focus_first_last (plug, GTK_DIR_TAB_BACKWARD);
break;
case XEMBED_FOCUS_CURRENT:
break;
}
break;
case XEMBED_FOCUS_OUT:
_gtk_window_set_has_toplevel_focus (window, FALSE);
break;
case XEMBED_GRAB_KEY:
case XEMBED_UNGRAB_KEY:
case XEMBED_GTK_GRAB_KEY:
case XEMBED_GTK_UNGRAB_KEY:
case XEMBED_REQUEST_FOCUS:
case XEMBED_FOCUS_NEXT:
case XEMBED_FOCUS_PREV:
g_warning ("GtkPlug: Invalid _XEMBED message %s received", _gtk_xembed_message_name (message));
break;
default:
GTK_NOTE(PLUGSOCKET,
g_message ("GtkPlug: Ignoring unknown _XEMBED message of type %d", message));
break;
}
}
GdkFilterReturn
_gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
GdkScreen *screen = gdk_drawable_get_screen (event->any.window);
GdkDisplay *display = gdk_screen_get_display (screen);
GtkPlug *plug = GTK_PLUG (data);
XEvent *xevent = (XEvent *)gdk_xevent;
GdkFilterReturn return_val;
return_val = GDK_FILTER_CONTINUE;
switch (xevent->type)
{
case ClientMessage:
if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED"))
{
_gtk_xembed_push_message (xevent);
handle_xembed_message (plug,
xevent->xclient.data.l[1],
xevent->xclient.data.l[2],
xevent->xclient.data.l[3],
xevent->xclient.data.l[4],
xevent->xclient.data.l[0]);
_gtk_xembed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "WM_DELETE_WINDOW"))
{
/* We filter these out because we take being reparented back to the
* root window as the reliable end of the embedding protocol
*/
return GDK_FILTER_REMOVE;
}
break;
case ReparentNotify:
{
XReparentEvent *xre = &xevent->xreparent;
gboolean was_embedded = plug->socket_window != NULL;
GTK_NOTE (PLUGSOCKET, g_message("GtkPlug: ReparentNotify received\n"));
return_val = GDK_FILTER_REMOVE;
g_object_ref (plug);
if (was_embedded)
{
/* End of embedding protocol for previous socket */
GTK_NOTE (PLUGSOCKET, g_message ("GtkPlug: end of embedding\n"));
/* FIXME: race if we remove from another socket and
* then add to a local window before we get notification
* Probably need check in _gtk_plug_add_to_socket
*/
if (xre->parent != GDK_WINDOW_XWINDOW (plug->socket_window))
{
GtkWidget *widget = GTK_WIDGET (plug);
gdk_window_set_user_data (plug->socket_window, NULL);
g_object_unref (plug->socket_window);
plug->socket_window = NULL;
/* Emit a delete window, as if the user attempted
* to close the toplevel. Simple as to how we
* handle WM_DELETE_WINDOW, if it isn't handled
* we destroy the widget. BUt only do this if
* we are being reparented to the root window.
* Moving from one embedder to another should
* be invisible to the app.
*/
if (xre->parent == GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)))
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkPlug: calling gtk_plug_send_delete_event()\n"));
_gtk_plug_send_delete_event (widget);
}
}
else
goto done;
}
if (xre->parent != GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)))
{
/* Start of embedding protocol */
GTK_NOTE (PLUGSOCKET, g_message ("GtkPlug: start of embedding\n"));
plug->socket_window = gdk_window_lookup_for_display (display, xre->parent);
if (plug->socket_window)
{
gpointer user_data = NULL;
gdk_window_get_user_data (plug->socket_window, &user_data);
if (user_data)
{
g_warning (G_STRLOC "Plug reparented unexpectedly into window in the same process");
plug->socket_window = NULL;
break;
}
g_object_ref (plug->socket_window);
}
else
{
plug->socket_window = gdk_window_foreign_new_for_display (display, xre->parent);
if (!plug->socket_window) /* Already gone */
break;
}
_gtk_plug_add_all_grabbed_keys (plug);
if (!was_embedded)
g_signal_emit_by_name (plug, "embedded");
}
done:
g_object_unref (plug);
break;
}
}
return GDK_FILTER_CONTINUE;
}

119
gtk/gtksocket-stub.c Normal file
View File

@ -0,0 +1,119 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Stub implementation of backend-specific GtkPlug functions. */
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "gtksocketprivate.h"
GdkNativeWindow
_gtk_socket_windowing_get_id (GtkSocket *socket)
{
return 0;
}
void
_gtk_socket_windowing_realize_window (GtkSocket *socket)
{
}
void
_gtk_socket_windowing_end_embedding_toplevel (GtkSocket *socket)
{
}
void
_gtk_socket_windowing_size_request (GtkSocket *socket)
{
}
void
_gtk_socket_windowing_send_key_event (GtkSocket *socket,
GdkEvent *gdk_event,
gboolean mask_key_presses)
{
}
void
_gtk_socket_windowing_focus_change (GtkSocket *socket,
gboolean focus_in)
{
}
void
_gtk_socket_windowing_update_active (GtkSocket *socket,
gboolean active)
{
}
void
_gtk_socket_windowing_update_modality (GtkSocket *socket,
gboolean modality)
{
}
void
_gtk_socket_windowing_focus (GtkSocket *socket,
GtkDirectionType direction)
{
}
void
_gtk_socket_windowing_send_configure_event (GtkSocket *socket)
{
}
void
_gtk_socket_windowing_select_plug_window_input (GtkSocket *socket)
{
}
void
_gtk_socket_windowing_embed_get_info (GtkSocket *socket)
{
}
void
_gtk_socket_windowing_embed_notify (GtkSocket *socket)
{
}
gboolean
_gtk_socket_windowing_embed_get_focus_wrapped (void)
{
return FALSE;
}
void
_gtk_socket_windowing_embed_set_focus_wrapped (void)
{
}
GdkFilterReturn
_gtk_socket_windowing_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
return GDK_FILTER_CONTINUE;
}

305
gtk/gtksocket-win32.c Normal file
View File

@ -0,0 +1,305 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 2005 Novell, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* By Tor Lillqvist <tml@novell.com> 2005 */
/*
* Modified by the GTK+ Team and others 1997-2005. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <config.h>
#include <string.h>
#include "gtkwindow.h"
#include "gtkplug.h"
#include "gtkprivate.h"
#include "gtksocket.h"
#include "gtksocketprivate.h"
#include "win32/gdkwin32.h"
#include "gtkwin32embed.h"
GdkNativeWindow
_gtk_socket_windowing_get_id (GtkSocket *socket)
{
g_return_val_if_fail (GTK_IS_SOCKET (socket), 0);
g_return_val_if_fail (GTK_WIDGET_ANCHORED (socket), 0);
if (!GTK_WIDGET_REALIZED (socket))
gtk_widget_realize (GTK_WIDGET (socket));
return (GdkNativeWindow) GDK_WINDOW_HWND (GTK_WIDGET (socket)->window);
}
void
_gtk_socket_windowing_realize_window (GtkSocket *socket)
{
/* XXX Anything needed? */
}
void
_gtk_socket_windowing_end_embedding_toplevel (GtkSocket *socket)
{
gtk_window_remove_embedded_xid (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (socket))),
(guint) GDK_WINDOW_HWND (socket->plug_window));
}
void
_gtk_socket_windowing_size_request (GtkSocket *socket)
{
MINMAXINFO mmi;
socket->request_width = 1;
socket->request_height = 1;
mmi.ptMaxSize.x = mmi.ptMaxSize.y = 16000; /* ??? */
mmi.ptMinTrackSize.x = mmi.ptMinTrackSize.y = 1;
mmi.ptMaxTrackSize.x = mmi.ptMaxTrackSize.y = 16000; /* ??? */
mmi.ptMaxPosition.x = mmi.ptMaxPosition.y = 0;
if (SendMessage (GDK_WINDOW_HWND (socket->plug_window), WM_GETMINMAXINFO,
0, (LPARAM) &mmi) == 0)
{
socket->request_width = mmi.ptMinTrackSize.x;
socket->request_height = mmi.ptMinTrackSize.y;
}
socket->have_size = TRUE;
}
void
_gtk_socket_windowing_send_key_event (GtkSocket *socket,
GdkEvent *gdk_event,
gboolean mask_key_presses)
{
PostMessage (GDK_WINDOW_HWND (socket->plug_window),
(gdk_event->type == GDK_KEY_PRESS ? WM_KEYDOWN : WM_KEYUP),
gdk_event->key.hardware_keycode, 0);
}
void
_gtk_socket_windowing_focus_change (GtkSocket *socket,
gboolean focus_in)
{
if (focus_in)
_gtk_win32_embed_send_focus_message (socket->plug_window,
GTK_WIN32_EMBED_FOCUS_IN,
GTK_WIN32_EMBED_FOCUS_CURRENT);
else
_gtk_win32_embed_send (socket->plug_window,
GTK_WIN32_EMBED_FOCUS_OUT,
0, 0);
}
void
_gtk_socket_windowing_update_active (GtkSocket *socket,
gboolean active)
{
_gtk_win32_embed_send (socket->plug_window,
(active ? GTK_WIN32_EMBED_WINDOW_ACTIVATE : GTK_WIN32_EMBED_WINDOW_DEACTIVATE),
0, 0);
}
void
_gtk_socket_windowing_update_modality (GtkSocket *socket,
gboolean modality)
{
_gtk_win32_embed_send (socket->plug_window,
(modality ? GTK_WIN32_EMBED_MODALITY_ON : GTK_WIN32_EMBED_MODALITY_OFF),
0, 0);
}
void
_gtk_socket_windowing_focus (GtkSocket *socket,
GtkDirectionType direction)
{
int detail = -1;
switch (direction)
{
case GTK_DIR_UP:
case GTK_DIR_LEFT:
case GTK_DIR_TAB_BACKWARD:
detail = GTK_WIN32_EMBED_FOCUS_LAST;
break;
case GTK_DIR_DOWN:
case GTK_DIR_RIGHT:
case GTK_DIR_TAB_FORWARD:
detail = GTK_WIN32_EMBED_FOCUS_FIRST;
break;
}
_gtk_win32_embed_send_focus_message (socket->plug_window,
GTK_WIN32_EMBED_FOCUS_IN,
detail);
}
void
_gtk_socket_windowing_send_configure_event (GtkSocket *socket)
{
/* XXX Nothing needed? */
}
void
_gtk_socket_windowing_select_plug_window_input (GtkSocket *socket)
{
/* XXX Nothing needed? */
}
void
_gtk_socket_windowing_embed_get_info (GtkSocket *socket)
{
socket->is_mapped = TRUE; /* XXX ? */
}
void
_gtk_socket_windowing_embed_notify (GtkSocket *socket)
{
/* XXX Nothing needed? */
}
gboolean
_gtk_socket_windowing_embed_get_focus_wrapped (void)
{
return _gtk_win32_embed_get_focus_wrapped ();
}
void
_gtk_socket_windowing_embed_set_focus_wrapped (void)
{
_gtk_win32_embed_set_focus_wrapped ();
}
GdkFilterReturn
_gtk_socket_windowing_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
GtkSocket *socket;
GtkWidget *widget;
MSG *msg;
GdkFilterReturn return_val;
socket = GTK_SOCKET (data);
return_val = GDK_FILTER_CONTINUE;
if (socket->plug_widget)
return return_val;
widget = GTK_WIDGET (socket);
msg = (MSG *) gdk_xevent;
switch (msg->message)
{
default:
if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_PARENT_NOTIFY))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: PARENT_NOTIFY received window=%#x version=%ld\n", msg->wParam, msg->lParam));
/* If we some day different protocols deployed need to add
* some more elaborate version handshake
*/
if (msg->lParam != GTK_WIN32_EMBED_PROTOCOL_VERSION)
g_warning ("GTK Win32 embedding protocol version mismatch, "
"client uses version %ld, we understand version %d",
msg->lParam, GTK_WIN32_EMBED_PROTOCOL_VERSION);
if (!socket->plug_window)
{
_gtk_socket_add_window (socket, msg->wParam, FALSE);
if (socket->plug_window)
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: window created"));
return_val = GDK_FILTER_REMOVE;
}
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_EVENT_PLUG_MAPPED))
{
gboolean was_mapped = socket->is_mapped;
gboolean is_mapped = msg->wParam != 0;
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: PLUG_MAPPED received is_mapped:%d\n", is_mapped));
if (was_mapped != is_mapped)
{
if (is_mapped)
_gtk_socket_handle_map_request (socket);
else
{
gdk_window_show (socket->plug_window);
_gtk_socket_unmap_notify (socket);
}
}
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_PLUG_RESIZED))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: PLUG_RESIZED received\n"));
socket->have_size = FALSE;
gtk_widget_queue_resize (widget);
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_REQUEST_FOCUS))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: REQUEST_FOCUS received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_socket_claim_focus (socket, TRUE);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_NEXT))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: FOCUS_NEXT received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_socket_advance_toplevel_focus (socket, GTK_DIR_TAB_FORWARD);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_PREV))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: FOCUS_PREV received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_socket_advance_toplevel_focus (socket, GTK_DIR_TAB_BACKWARD);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_GRAB_KEY))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: GRAB_KEY received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_socket_add_grabbed_key (socket, msg->wParam, msg->lParam);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_UNGRAB_KEY))
{
GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: UNGRAB_KEY received\n"));
_gtk_win32_embed_push_message (msg);
_gtk_socket_remove_grabbed_key (socket, msg->wParam, msg->lParam);
_gtk_win32_embed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
break;
}
return return_val;
}

620
gtk/gtksocket-x11.c Normal file
View File

@ -0,0 +1,620 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* By Owen Taylor <otaylor@gtk.org> 98/4/4 */
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <config.h>
#include <string.h>
#include "gdk/gdkkeysyms.h"
#include "gtkalias.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkwindow.h"
#include "gtkplug.h"
#include "gtkprivate.h"
#include "gtksocket.h"
#include "gtksocketprivate.h"
#include "gtkdnd.h"
#include "x11/gdkx.h"
#include "gtkxembed.h"
#include "gtkalias.h"
static gboolean xembed_get_info (GdkWindow *gdk_window,
unsigned long *version,
unsigned long *flags);
/* From Tk */
#define EMBEDDED_APP_WANTS_FOCUS NotifyNormal+20
GdkNativeWindow
_gtk_socket_windowing_get_id (GtkSocket *socket)
{
return GDK_WINDOW_XWINDOW (GTK_WIDGET (socket)->window);
}
void
_gtk_socket_windowing_realize_window (GtkSocket *socket)
{
GdkWindow *window = GTK_WIDGET (socket)->window;
XWindowAttributes xattrs;
XGetWindowAttributes (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XWINDOW (window),
&xattrs);
XSelectInput (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XWINDOW (window),
xattrs.your_event_mask |
SubstructureNotifyMask | SubstructureRedirectMask);
}
void
_gtk_socket_windowing_end_embedding_toplevel (GtkSocket *socket)
{
gtk_window_remove_embedded_xid (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (socket))),
GDK_WINDOW_XWINDOW (socket->plug_window));
}
void
_gtk_socket_windowing_size_request (GtkSocket *socket)
{
XSizeHints hints;
long supplied;
gdk_error_trap_push ();
socket->request_width = 1;
socket->request_height = 1;
if (XGetWMNormalHints (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
&hints, &supplied))
{
if (hints.flags & PMinSize)
{
socket->request_width = hints.min_width;
socket->request_height = hints.min_height;
}
else if (hints.flags & PBaseSize)
{
socket->request_width = hints.base_width;
socket->request_height = hints.base_height;
}
}
socket->have_size = TRUE;
gdk_error_trap_pop ();
}
void
_gtk_socket_windowing_send_key_event (GtkSocket *socket,
GdkEvent *gdk_event,
gboolean mask_key_presses)
{
XEvent xevent;
GdkScreen *screen = gdk_drawable_get_screen (socket->plug_window);
xevent.xkey.type = (gdk_event->type == GDK_KEY_PRESS) ? KeyPress : KeyRelease;
xevent.xkey.window = GDK_WINDOW_XWINDOW (socket->plug_window);
xevent.xkey.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
xevent.xkey.subwindow = None;
xevent.xkey.time = gdk_event->key.time;
xevent.xkey.x = 0;
xevent.xkey.y = 0;
xevent.xkey.x_root = 0;
xevent.xkey.y_root = 0;
xevent.xkey.state = gdk_event->key.state;
xevent.xkey.keycode = gdk_event->key.hardware_keycode;
xevent.xkey.same_screen = True;/* FIXME ? */
gdk_error_trap_push ();
XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
False,
(mask_key_presses ? KeyPressMask : NoEventMask),
&xevent);
gdk_display_sync (gdk_screen_get_display (screen));
gdk_error_trap_pop ();
}
void
_gtk_socket_windowing_focus_change (GtkSocket *socket,
gboolean focus_in)
{
if (focus_in)
_gtk_xembed_send_focus_message (socket->plug_window,
XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT);
else
_gtk_xembed_send_message (socket->plug_window,
XEMBED_FOCUS_OUT, 0, 0, 0);
}
void
_gtk_socket_windowing_update_active (GtkSocket *socket,
gboolean active)
{
_gtk_xembed_send_message (socket->plug_window,
active ? XEMBED_WINDOW_ACTIVATE : XEMBED_WINDOW_DEACTIVATE,
0, 0, 0);
}
void
_gtk_socket_windowing_update_modality (GtkSocket *socket,
gboolean modality)
{
_gtk_xembed_send_message (socket->plug_window,
modality ? XEMBED_MODALITY_ON : XEMBED_MODALITY_OFF,
0, 0, 0);
}
void
_gtk_socket_windowing_focus (GtkSocket *socket,
GtkDirectionType direction)
{
gint detail = -1;
switch (direction)
{
case GTK_DIR_UP:
case GTK_DIR_LEFT:
case GTK_DIR_TAB_BACKWARD:
detail = XEMBED_FOCUS_LAST;
break;
case GTK_DIR_DOWN:
case GTK_DIR_RIGHT:
case GTK_DIR_TAB_FORWARD:
detail = XEMBED_FOCUS_FIRST;
break;
}
_gtk_xembed_send_focus_message (socket->plug_window, XEMBED_FOCUS_IN, detail);
}
void
_gtk_socket_windowing_send_configure_event (GtkSocket *socket)
{
XEvent event;
gint x, y;
g_return_if_fail (socket->plug_window != NULL);
event.xconfigure.type = ConfigureNotify;
event.xconfigure.event = GDK_WINDOW_XWINDOW (socket->plug_window);
event.xconfigure.window = GDK_WINDOW_XWINDOW (socket->plug_window);
/* The ICCCM says that synthetic events should have root relative
* coordinates. We still aren't really ICCCM compliant, since
* we don't send events when the real toplevel is moved.
*/
gdk_error_trap_push ();
gdk_window_get_origin (socket->plug_window, &x, &y);
gdk_error_trap_pop ();
event.xconfigure.x = x;
event.xconfigure.y = y;
event.xconfigure.width = GTK_WIDGET(socket)->allocation.width;
event.xconfigure.height = GTK_WIDGET(socket)->allocation.height;
event.xconfigure.border_width = 0;
event.xconfigure.above = None;
event.xconfigure.override_redirect = False;
gdk_error_trap_push ();
XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
GDK_WINDOW_XWINDOW (socket->plug_window),
False, NoEventMask, &event);
gdk_display_sync (gtk_widget_get_display (GTK_WIDGET (socket)));
gdk_error_trap_pop ();
}
void
_gtk_socket_windowing_select_plug_window_input (GtkSocket *socket)
{
XSelectInput (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (socket))),
GDK_WINDOW_XWINDOW (socket->plug_window),
StructureNotifyMask | PropertyChangeMask);
}
void
_gtk_socket_windowing_embed_get_info (GtkSocket *socket)
{
unsigned long version;
unsigned long flags;
socket->xembed_version = -1;
if (xembed_get_info (socket->plug_window, &version, &flags))
{
socket->xembed_version = MIN (GTK_XEMBED_PROTOCOL_VERSION, version);
socket->is_mapped = (flags & XEMBED_MAPPED) != 0;
}
else
{
/* FIXME, we should probably actually check the state before we started */
socket->is_mapped = TRUE;
}
}
void
_gtk_socket_windowing_embed_notify (GtkSocket *socket)
{
_gtk_xembed_send_message (socket->plug_window,
XEMBED_EMBEDDED_NOTIFY, 0,
GDK_WINDOW_XWINDOW (GTK_WIDGET (socket)->window),
socket->xembed_version);
}
static gboolean
xembed_get_info (GdkWindow *window,
unsigned long *version,
unsigned long *flags)
{
GdkDisplay *display = gdk_drawable_get_display (window);
Atom xembed_info_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO");
Atom type;
int format;
unsigned long nitems, bytes_after;
unsigned char *data;
unsigned long *data_long;
int status;
gdk_error_trap_push();
status = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XWINDOW (window),
xembed_info_atom,
0, 2, False,
xembed_info_atom, &type, &format,
&nitems, &bytes_after, &data);
gdk_error_trap_pop();
if (status != Success)
return FALSE; /* Window vanished? */
if (type == None) /* No info property */
return FALSE;
if (type != xembed_info_atom)
{
g_warning ("_XEMBED_INFO property has wrong type\n");
return FALSE;
}
if (nitems < 2)
{
g_warning ("_XEMBED_INFO too short\n");
XFree (data);
return FALSE;
}
data_long = (unsigned long *)data;
if (version)
*version = data_long[0];
if (flags)
*flags = data_long[1] & XEMBED_MAPPED;
XFree (data);
return TRUE;
}
gboolean
_gtk_socket_windowing_embed_get_focus_wrapped (void)
{
return _gtk_xembed_get_focus_wrapped ();
}
void
_gtk_socket_windowing_embed_set_focus_wrapped (void)
{
_gtk_xembed_set_focus_wrapped ();
}
static void
handle_xembed_message (GtkSocket *socket,
XEmbedMessageType message,
glong detail,
glong data1,
glong data2,
guint32 time)
{
GTK_NOTE (PLUGSOCKET,
g_message ("GtkSocket: %s received", _gtk_xembed_message_name (message)));
switch (message)
{
case XEMBED_EMBEDDED_NOTIFY:
case XEMBED_WINDOW_ACTIVATE:
case XEMBED_WINDOW_DEACTIVATE:
case XEMBED_MODALITY_ON:
case XEMBED_MODALITY_OFF:
case XEMBED_FOCUS_IN:
case XEMBED_FOCUS_OUT:
g_warning ("GtkSocket: Invalid _XEMBED message %s received", _gtk_xembed_message_name (message));
break;
case XEMBED_REQUEST_FOCUS:
_gtk_socket_claim_focus (socket, TRUE);
break;
case XEMBED_FOCUS_NEXT:
case XEMBED_FOCUS_PREV:
_gtk_socket_advance_toplevel_focus (socket,
(message == XEMBED_FOCUS_NEXT ?
GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD));
break;
case XEMBED_GTK_GRAB_KEY:
_gtk_socket_add_grabbed_key (socket, data1, data2);
break;
case XEMBED_GTK_UNGRAB_KEY:
_gtk_socket_remove_grabbed_key (socket, data1, data2);
break;
case XEMBED_GRAB_KEY:
case XEMBED_UNGRAB_KEY:
break;
default:
GTK_NOTE (PLUGSOCKET,
g_message ("GtkSocket: Ignoring unknown _XEMBED message of type %d", message));
break;
}
}
GdkFilterReturn
_gtk_socket_windowing_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
GtkSocket *socket;
GtkWidget *widget;
GdkDisplay *display;
XEvent *xevent;
GdkFilterReturn return_val;
socket = GTK_SOCKET (data);
return_val = GDK_FILTER_CONTINUE;
if (socket->plug_widget)
return return_val;
widget = GTK_WIDGET (socket);
xevent = (XEvent *)gdk_xevent;
display = gtk_widget_get_display (widget);
switch (xevent->type)
{
case ClientMessage:
if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED"))
{
_gtk_xembed_push_message (xevent);
handle_xembed_message (socket,
xevent->xclient.data.l[1],
xevent->xclient.data.l[2],
xevent->xclient.data.l[3],
xevent->xclient.data.l[4],
xevent->xclient.data.l[0]);
_gtk_xembed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
break;
case CreateNotify:
{
XCreateWindowEvent *xcwe = &xevent->xcreatewindow;
if (!socket->plug_window)
{
_gtk_socket_add_window (socket, xcwe->window, FALSE);
if (socket->plug_window)
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - window created"));
}
}
return_val = GDK_FILTER_REMOVE;
break;
}
case ConfigureRequest:
{
XConfigureRequestEvent *xcre = &xevent->xconfigurerequest;
if (!socket->plug_window)
_gtk_socket_add_window (socket, xcre->window, FALSE);
if (socket->plug_window)
{
GtkSocketPrivate *private = _gtk_socket_get_private (socket);
if (xcre->value_mask & (CWWidth | CWHeight))
{
GTK_NOTE (PLUGSOCKET,
g_message ("GtkSocket - configure request: %d %d",
socket->request_width,
socket->request_height));
private->resize_count++;
gtk_widget_queue_resize (widget);
}
else if (xcre->value_mask & (CWX | CWY))
{
_gtk_socket_windowing_send_configure_event (socket);
}
/* Ignore stacking requests. */
return_val = GDK_FILTER_REMOVE;
}
break;
}
case DestroyNotify:
{
XDestroyWindowEvent *xdwe = &xevent->xdestroywindow;
/* Note that we get destroy notifies both from SubstructureNotify on
* our window and StructureNotify on socket->plug_window
*/
if (socket->plug_window && (xdwe->window == GDK_WINDOW_XWINDOW (socket->plug_window)))
{
gboolean result;
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - destroy notify"));
gdk_window_destroy_notify (socket->plug_window);
_gtk_socket_end_embedding (socket);
g_object_ref (widget);
g_signal_emit_by_name (widget, "plug_removed", 0, &result);
if (!result)
gtk_widget_destroy (widget);
g_object_unref (widget);
return_val = GDK_FILTER_REMOVE;
}
break;
}
case FocusIn:
if (xevent->xfocus.mode == EMBEDDED_APP_WANTS_FOCUS)
{
_gtk_socket_claim_focus (socket, TRUE);
}
return_val = GDK_FILTER_REMOVE;
break;
case FocusOut:
return_val = GDK_FILTER_REMOVE;
break;
case MapRequest:
if (!socket->plug_window)
{
_gtk_socket_add_window (socket, xevent->xmaprequest.window, FALSE);
}
if (socket->plug_window)
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - Map Request"));
_gtk_socket_handle_map_request (socket);
return_val = GDK_FILTER_REMOVE;
}
break;
case PropertyNotify:
if (socket->plug_window &&
xevent->xproperty.window == GDK_WINDOW_XWINDOW (socket->plug_window))
{
GdkDragProtocol protocol;
if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "WM_NORMAL_HINTS"))
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - received PropertyNotify for plug's WM_NORMAL_HINTS"));
socket->have_size = FALSE;
gtk_widget_queue_resize (widget);
return_val = GDK_FILTER_REMOVE;
}
else if ((xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "XdndAware")) ||
(xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "_MOTIF_DRAG_RECEIVER_INFO")))
{
gdk_error_trap_push ();
if (gdk_drag_get_protocol_for_display (display,
xevent->xproperty.window,
&protocol))
gtk_drag_dest_set_proxy (GTK_WIDGET (socket),
socket->plug_window,
protocol, TRUE);
gdk_display_sync (display);
gdk_error_trap_pop ();
return_val = GDK_FILTER_REMOVE;
}
else if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO"))
{
unsigned long flags;
if (xembed_get_info (socket->plug_window, NULL, &flags))
{
gboolean was_mapped = socket->is_mapped;
gboolean is_mapped = (flags & XEMBED_MAPPED) != 0;
if (was_mapped != is_mapped)
{
if (is_mapped)
_gtk_socket_handle_map_request (socket);
else
{
gdk_error_trap_push ();
gdk_window_show (socket->plug_window);
gdk_flush ();
gdk_error_trap_pop ();
_gtk_socket_unmap_notify (socket);
}
}
}
return_val = GDK_FILTER_REMOVE;
}
}
break;
case ReparentNotify:
{
XReparentEvent *xre = &xevent->xreparent;
GTK_NOTE (PLUGSOCKET, g_message ("GtkPlug: ReparentNotify received\n"));
if (!socket->plug_window && xre->parent == GDK_WINDOW_XWINDOW (widget->window))
{
_gtk_socket_add_window (socket, xre->window, FALSE);
if (socket->plug_window)
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - window reparented"));
}
return_val = GDK_FILTER_REMOVE;
}
break;
}
case UnmapNotify:
if (socket->plug_window &&
xevent->xunmap.window == GDK_WINDOW_XWINDOW (socket->plug_window))
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - Unmap notify"));
_gtk_socket_unmap_notify (socket);
return_val = GDK_FILTER_REMOVE;
}
break;
}
return return_val;
}

135
gtk/gtkwin32embed.c Normal file
View File

@ -0,0 +1,135 @@
/* GTK - The GIMP Toolkit
* gtkwin32embed.c: Utilities for Win32 embedding
* Copyright (C) 2005, Novell, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* By Tor Lillqvist <tml@novell.com> 2005 */
#include <config.h>
#include "win32/gdkwin32.h"
#include "gtkwin32embed.h"
static guint message_type[GTK_WIN32_EMBED_LAST];
static GSList *current_messages;
guint
_gtk_win32_embed_message_type (GtkWin32EmbedMessageType type)
{
if (type < 0 || type >= GTK_WIN32_EMBED_LAST)
return 0;
if (message_type[type] == 0)
{
char name[100];
sprintf (name, "gtk-win32-embed:%d", type);
message_type[type] = RegisterWindowMessage (name);
}
return message_type[type];
}
void
_gtk_win32_embed_push_message (MSG *msg)
{
MSG *message = g_new (MSG, 1);
*message = *msg;
current_messages = g_slist_prepend (current_messages, message);
}
void
_gtk_win32_embed_pop_message (void)
{
MSG *message = current_messages->data;
current_messages = g_slist_delete_link (current_messages, current_messages);
g_free (message);
}
void
_gtk_win32_embed_send (GdkWindow *recipient,
GtkWin32EmbedMessageType message,
gint wparam,
gint lparam)
{
PostMessage (GDK_WINDOW_HWND (recipient),
_gtk_win32_embed_message_type (message),
wparam, lparam);
}
void
_gtk_win32_embed_send_focus_message (GdkWindow *recipient,
GtkWin32EmbedMessageType message,
gint wparam)
{
int lparam = 0;
if (!recipient)
return;
g_return_if_fail (GDK_IS_WINDOW (recipient));
g_return_if_fail (message == GTK_WIN32_EMBED_FOCUS_IN ||
message == GTK_WIN32_EMBED_FOCUS_NEXT ||
message == GTK_WIN32_EMBED_FOCUS_PREV);
if (current_messages)
{
MSG *msg = current_messages->data;
if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_IN) ||
msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_NEXT) ||
msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_PREV))
lparam = (msg->lParam & GTK_WIN32_EMBED_FOCUS_WRAPAROUND);
}
_gtk_win32_embed_send (recipient, message, wparam, lparam);
}
void
_gtk_win32_embed_set_focus_wrapped (void)
{
MSG *msg;
g_return_if_fail (current_messages != NULL);
msg = current_messages->data;
g_return_if_fail (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_PREV) ||
msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_NEXT));
msg->lParam |= GTK_WIN32_EMBED_FOCUS_WRAPAROUND;
}
gboolean
_gtk_win32_embed_get_focus_wrapped (void)
{
MSG *msg;
g_return_val_if_fail (current_messages != NULL, FALSE);
msg = current_messages->data;
return (msg->lParam & GTK_WIN32_EMBED_FOCUS_WRAPAROUND) != 0;
}

95
gtk/gtkwin32embed.h Normal file
View File

@ -0,0 +1,95 @@
/* GTK - The GIMP Toolkit
* gtkwin32embed.h: Utilities for Win32 embedding
* Copyright (C) 2005, Novell, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* By Tor Lillqvist <tml@novell.com> 2005 */
#ifndef __GTK_WIN32_EMBED_H__
#define __GTK_WIN32_EMBED_H__
G_BEGIN_DECLS
#define GTK_WIN32_EMBED_PROTOCOL_VERSION 1
/*
* When the plug and socket are in separate processes they use a
* simple protocol, more or less based on XEMBED. The protocol uses
* registered window messages. The name passed to
* RegisterWindowMessage() is gtk-win32-embed:%d, with %d being the
* numeric value of an GtkWin32EmbedMessageType enum. Each message
* carries the message type enum value and two integers, the "wparam"
* and "lparam", like all window messages.
*
* So far all the window messages are posted to the other
* process. Maybe some later enhancement will add also messages that
* are sent, i.e. where the sending process waits for the receiving
* process's window procedure to handle the message.
*/
typedef enum { /* send or post? */
/* First those sent from the socket
* to the plug
*/
GTK_WIN32_EMBED_WINDOW_ACTIVATE, /* post */
GTK_WIN32_EMBED_WINDOW_DEACTIVATE, /* post */
GTK_WIN32_EMBED_FOCUS_IN, /* post */
GTK_WIN32_EMBED_FOCUS_OUT, /* post */
GTK_WIN32_EMBED_MODALITY_ON, /* post */
GTK_WIN32_EMBED_MODALITY_OFF, /* post */
/* Then the ones sent from the plug
* to the socket.
*/
GTK_WIN32_EMBED_PARENT_NOTIFY, /* post */
GTK_WIN32_EMBED_EVENT_PLUG_MAPPED, /* post */
GTK_WIN32_EMBED_PLUG_RESIZED, /* post */
GTK_WIN32_EMBED_REQUEST_FOCUS, /* post */
GTK_WIN32_EMBED_FOCUS_NEXT, /* post */
GTK_WIN32_EMBED_FOCUS_PREV, /* post */
GTK_WIN32_EMBED_GRAB_KEY, /* post */
GTK_WIN32_EMBED_UNGRAB_KEY, /* post */
GTK_WIN32_EMBED_LAST
} GtkWin32EmbedMessageType;
/* wParam values for GTK_WIN32_EMBED_FOCUS_IN: */
#define GTK_WIN32_EMBED_FOCUS_CURRENT 0
#define GTK_WIN32_EMBED_FOCUS_FIRST 1
#define GTK_WIN32_EMBED_FOCUS_LAST 2
/* Flags for lParam in GTK_WIN32_EMBED_FOCUS_IN, GTK_WIN32_EMBED_FOCUS_NEXT,
* GTK_WIN32_EMBED_FOCUS_PREV
*/
#define GTK_WIN32_EMBED_FOCUS_WRAPAROUND (1 << 0)
guint _gtk_win32_embed_message_type (GtkWin32EmbedMessageType type);
void _gtk_win32_embed_push_message (MSG *msg);
void _gtk_win32_embed_pop_message (void);
void _gtk_win32_embed_send (GdkWindow *recipient,
GtkWin32EmbedMessageType message,
gint wparam,
gint lparam);
void _gtk_win32_embed_send_focus_message (GdkWindow *recipient,
GtkWin32EmbedMessageType message,
gint wparam);
void _gtk_win32_embed_set_focus_wrapped (void);
gboolean _gtk_win32_embed_get_focus_wrapped (void);
G_END_DECLS
#endif /* __GTK_WIN32_EMBED_H__ */