* 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 Library General Public
+ * 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
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * 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-1999. See the AUTHORS
+ * 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 "gdkx.h"
+#include "gdkconfig.h"
+
+#if defined (GDK_WINDOWING_X11)
+#include "x11/gdkx.h"
+#elif defined (GDK_WINDOWING_WIN32)
+#include "win32/gdkwin32.h"
+#elif defined(GDK_WINDOWING_FB)
+#include "linux-fb/gdkfb.h"
+#endif
+
#include "gdk/gdkkeysyms.h"
+#include "gtkmain.h"
#include "gtkwindow.h"
#include "gtksignal.h"
#include "gtksocket.h"
#include "gtkdnd.h"
+#include "xembed.h"
+
#ifdef GDK_WINDOWING_X11
/* Forward declararations */
-static void gtk_socket_class_init (GtkSocketClass *klass);
-static void gtk_socket_init (GtkSocket *socket);
-static void gtk_socket_realize (GtkWidget *widget);
-static void gtk_socket_unrealize (GtkWidget *widget);
-static void gtk_socket_size_request (GtkWidget *widget,
- GtkRequisition *requisition);
-static void gtk_socket_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
-static gint gtk_socket_focus_in_event (GtkWidget *widget,
- GdkEventFocus *event);
-static void gtk_socket_claim_focus (GtkSocket *socket);
-static gint gtk_socket_focus_out_event (GtkWidget *widget,
- GdkEventFocus *event);
-static void gtk_socket_send_configure_event (GtkSocket *socket);
-static gint gtk_socket_focus (GtkContainer *container,
- GtkDirectionType direction);
-static GdkFilterReturn gtk_socket_filter_func (GdkXEvent *gdk_xevent,
- GdkEvent *event,
- gpointer data);
+static void gtk_socket_class_init (GtkSocketClass *klass);
+static void gtk_socket_init (GtkSocket *socket);
+static void gtk_socket_realize (GtkWidget *widget);
+static void gtk_socket_unrealize (GtkWidget *widget);
+static void gtk_socket_size_request (GtkWidget *widget,
+ GtkRequisition *requisition);
+static void gtk_socket_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
+static void gtk_socket_hierarchy_changed (GtkWidget *widget);
+static void gtk_socket_grab_notify (GtkWidget *widget,
+ gboolean was_grabbed);
+static gboolean gtk_socket_key_press_event (GtkWidget *widget,
+ GdkEventKey *event);
+static gboolean gtk_socket_focus_in_event (GtkWidget *widget,
+ GdkEventFocus *event);
+static void gtk_socket_claim_focus (GtkSocket *socket);
+static gboolean gtk_socket_focus_out_event (GtkWidget *widget,
+ GdkEventFocus *event);
+static void gtk_socket_send_configure_event (GtkSocket *socket);
+static gboolean gtk_socket_focus (GtkContainer *container,
+ GtkDirectionType direction);
+static GdkFilterReturn gtk_socket_filter_func (GdkXEvent *gdk_xevent,
+ GdkEvent *event,
+ gpointer data);
+
+static void send_xembed_message (GtkSocket *socket,
+ glong message,
+ glong detail,
+ glong data1,
+ glong data2,
+ guint32 time);
/* From Tk */
#define EMBEDDED_APP_WANTS_FOCUS NotifyNormal+20
static GtkWidgetClass *parent_class = NULL;
GtkType
-gtk_socket_get_type ()
+gtk_socket_get_type (void)
{
static GtkType socket_type = 0;
if (!socket_type)
{
- static const GtkTypeInfo socket_info =
+ static const GTypeInfo socket_info =
{
- "GtkSocket",
- sizeof (GtkSocket),
sizeof (GtkSocketClass),
- (GtkClassInitFunc) gtk_socket_class_init,
- (GtkObjectInitFunc) gtk_socket_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_socket_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkSocket),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_socket_init,
};
- socket_type = gtk_type_unique (gtk_container_get_type (), &socket_info);
+ socket_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkSocket", &socket_info, 0);
}
return socket_type;
static void
gtk_socket_class_init (GtkSocketClass *class)
{
- GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
- object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
- parent_class = gtk_type_class (gtk_widget_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
widget_class->realize = gtk_socket_realize;
widget_class->unrealize = gtk_socket_unrealize;
widget_class->size_request = gtk_socket_size_request;
widget_class->size_allocate = gtk_socket_size_allocate;
+ widget_class->hierarchy_changed = gtk_socket_hierarchy_changed;
+#if 0
+ widget_class->grab_notify = gtk_socket_grab_notify;
+#endif
+ widget_class->key_press_event = gtk_socket_key_press_event;
widget_class->focus_in_event = gtk_socket_focus_in_event;
widget_class->focus_out_event = gtk_socket_focus_out_event;
}
GtkWidget*
-gtk_socket_new ()
+gtk_socket_new (void)
{
GtkSocket *socket;
- socket = gtk_type_new (gtk_socket_get_type ());
+ socket = g_object_new (GTK_TYPE_SOCKET, NULL);
return GTK_WIDGET (socket);
}
void
-gtk_socket_steal (GtkSocket *socket, guint32 id)
+gtk_socket_steal (GtkSocket *socket, GdkNativeWindow id)
{
GtkWidget *widget;
-
+ gpointer user_data = NULL;
+
widget = GTK_WIDGET (socket);
socket->plug_window = gdk_window_lookup (id);
gdk_error_trap_push ();
+
+ if (socket->plug_window)
+ gdk_window_get_user_data (socket->plug_window,
+ &user_data);
- if (socket->plug_window && socket->plug_window->user_data)
+ if (user_data)
{
/*
GtkWidget *child_widget;
if (toplevel && GTK_IS_WINDOW (toplevel))
gtk_window_remove_embedded_xid (GTK_WINDOW (toplevel),
GDK_WINDOW_XWINDOW (socket->plug_window));
+
+ socket->plug_window = NULL;
}
+#if 0
+ if (socket->grabbed_keys)
+ {
+ g_hash_table_foreach (socket->grabbed_keys, (GHFunc)g_free, NULL);
+ g_hash_table_destroy (socket->grabbed_keys);
+ socket->grabbed_keys = NULL;
+ }
+#endif
+
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
gdk_error_trap_pop ();
}
- requisition->width = socket->request_width;
- requisition->height = socket->request_height;
+ requisition->width = MAX (socket->request_width, 1);
+ requisition->height = MAX (socket->request_height, 1);
}
static void
}
}
-static gint
-gtk_socket_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
+#if 0
+
+typedef struct
{
- GtkSocket *socket;
- g_return_val_if_fail (GTK_IS_SOCKET (widget), FALSE);
- socket = GTK_SOCKET (widget);
+ guint accelerator_key;
+ GdkModifierType accelerator_mods;
+} GrabbedKey;
+
+static guint
+grabbed_key_hash (gconstpointer a)
+{
+ const GrabbedKey *key = a;
+ guint h;
+
+ h = key->accelerator_key << 16;
+ h ^= key->accelerator_key >> 16;
+ h ^= key->accelerator_mods;
+
+ return h;
+}
+
+static gboolean
+grabbed_key_equal (gconstpointer a, gconstpointer b)
+{
+ const GrabbedKey *keya = a;
+ const GrabbedKey *keyb = b;
+
+ return (keya->accelerator_key == keyb->accelerator_key &&
+ keya->accelerator_mods == keyb->accelerator_mods);
+}
+
+static void
+add_grabbed_key (GtkSocket *socket,
+ guint hardware_keycode,
+ GdkModifierType mods)
+{
+ GrabbedKey key;
+ GrabbedKey *new_key;
+ GrabbedKey *found_key;
+
+ if (socket->grabbed_keys)
+ {
+ key.accelerator_key = hardware_keycode;
+ key.accelerator_mods = mods;
+
+ found_key = g_hash_table_lookup (socket->grabbed_keys, &key);
+
+ if (found_key)
+ {
+ g_warning ("GtkSocket: request to add already present grabbed key %u,%#x\n",
+ hardware_keycode, mods);
+ return;
+ }
+ }
+
+ if (!socket->grabbed_keys)
+ socket->grabbed_keys = g_hash_table_new (grabbed_key_hash, grabbed_key_equal);
+
+ new_key = g_new (GrabbedKey, 1);
+
+ new_key->accelerator_key = hardware_keycode;
+ new_key->accelerator_mods = mods;
+
+ g_hash_table_insert (socket->grabbed_keys, new_key, new_key);
+}
+
+static void
+remove_grabbed_key (GtkSocket *socket,
+ guint hardware_keycode,
+ GdkModifierType mods)
+{
+ GrabbedKey key;
+ GrabbedKey *found_key = NULL;
+
+ if (socket->grabbed_keys)
+ {
+ key.accelerator_key = hardware_keycode;
+ key.accelerator_mods = mods;
+
+ found_key = g_hash_table_lookup (socket->grabbed_keys, &key);
+ }
+
+ if (found_key)
+ {
+ g_hash_table_remove (socket->grabbed_keys, &key);
+ g_free (found_key);
+ }
+ else
+ g_warning ("GtkSocket: request to remove non-present grabbed key %u,%#x\n",
+ hardware_keycode, mods);
+}
+
+static gboolean
+toplevel_key_press_handler (GtkWidget *toplevel,
+ GdkEventKey *event,
+ GtkSocket *socket)
+{
+ GrabbedKey search_key;
+
+ search_key.accelerator_key = event->hardware_keycode;
+ search_key.accelerator_mods = event->state;
+
+ if (socket->grabbed_keys &&
+ g_hash_table_lookup (socket->grabbed_keys, &search_key))
+ {
+ gtk_socket_key_press_event (GTK_WIDGET (socket), event);
+ gtk_signal_emit_stop_by_name (GTK_OBJECT (toplevel), "key_press_event");
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+#endif
+
+static void
+toplevel_focus_in_handler (GtkWidget *toplevel,
+ GdkEventFocus *event,
+ GtkSocket *socket)
+{
+ /* It appears spurious focus in events can occur when
+ * the window is hidden. So we'll just check to see if
+ * the window is visible before actually handling the
+ * event. (Comment from gtkwindow.c)
+ */
+ if (GTK_WIDGET_VISIBLE (toplevel))
+ send_xembed_message (socket, XEMBED_WINDOW_ACTIVATE, 0, 0, 0,
+ gtk_get_current_event_time ()); /* Will be GDK_CURRENT_TIME */
+}
+
+static void
+toplevel_focus_out_handler (GtkWidget *toplevel,
+ GdkEventFocus *event,
+ GtkSocket *socket)
+{
+ send_xembed_message (socket, XEMBED_WINDOW_DEACTIVATE, 0, 0, 0,
+ gtk_get_current_event_time ()); /* Will be GDK_CURRENT_TIME */
+}
+
+static void
+gtk_socket_hierarchy_changed (GtkWidget *widget)
+{
+ GtkSocket *socket = GTK_SOCKET (widget);
+ GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+
+ if (toplevel && !GTK_IS_WINDOW (toplevel))
+ toplevel = NULL;
+
+ if (toplevel != socket->toplevel)
+ {
+ if (socket->toplevel)
+ {
+#if 0
+ gtk_signal_disconnect_by_func (GTK_OBJECT (socket->toplevel), GTK_SIGNAL_FUNC (toplevel_key_press_handler), socket);
+#endif
+ gtk_signal_disconnect_by_func (GTK_OBJECT (socket->toplevel), GTK_SIGNAL_FUNC (toplevel_focus_in_handler), socket);
+ gtk_signal_disconnect_by_func (GTK_OBJECT (socket->toplevel), GTK_SIGNAL_FUNC (toplevel_focus_out_handler), socket);
+ }
+
+ socket->toplevel = toplevel;
+
+ if (toplevel)
+ {
+#if 0
+ gtk_signal_connect (GTK_OBJECT (socket->toplevel), "key_press_event",
+ GTK_SIGNAL_FUNC (toplevel_key_press_handler), socket);
+#endif
+ gtk_signal_connect (GTK_OBJECT (socket->toplevel), "focus_in_event",
+ GTK_SIGNAL_FUNC (toplevel_focus_in_handler), socket);
+ gtk_signal_connect (GTK_OBJECT (socket->toplevel), "focus_out_event",
+ GTK_SIGNAL_FUNC (toplevel_focus_out_handler), socket);
+ }
+ }
+}
+
+static void
+gtk_socket_grab_notify (GtkWidget *widget,
+ gboolean was_grabbed)
+{
+ send_xembed_message (GTK_SOCKET (widget),
+ was_grabbed ? XEMBED_MODALITY_OFF : XEMBED_MODALITY_ON,
+ 0, 0, 0, gtk_get_current_event_time ());
+}
- if (socket->focus_in && socket->plug_window)
+static gboolean
+gtk_socket_key_press_event (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ GtkSocket *socket = GTK_SOCKET (widget);
+
+ if (socket->plug_window)
{
+ XEvent xevent;
+
+ xevent.xkey.type = KeyPress;
+ xevent.xkey.display = GDK_WINDOW_XDISPLAY (event->window);
+ xevent.xkey.window = GDK_WINDOW_XWINDOW (socket->plug_window);
+ xevent.xkey.root = GDK_ROOT_WINDOW ();
+ xevent.xkey.time = event->time;
+ /* FIXME, the following might cause problems for non-GTK apps */
+ xevent.xkey.x = 0;
+ xevent.xkey.y = 0;
+ xevent.xkey.x_root = 0;
+ xevent.xkey.y_root = 0;
+ xevent.xkey.state = event->state;
+ xevent.xkey.keycode = event->hardware_keycode;
+ xevent.xkey.same_screen = TRUE; /* FIXME ? */
+
gdk_error_trap_push ();
- XSetInputFocus (GDK_DISPLAY (),
- GDK_WINDOW_XWINDOW (socket->plug_window),
- RevertToParent, GDK_CURRENT_TIME);
- gdk_flush();
+ XSendEvent (gdk_display,
+ GDK_WINDOW_XWINDOW (socket->plug_window),
+ False, NoEventMask, &xevent);
+ gdk_flush ();
gdk_error_trap_pop ();
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+static gboolean
+gtk_socket_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
+{
+ GtkSocket *socket = GTK_SOCKET (widget);
+
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ {
+ GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
+
+ if (socket->plug_window)
+ {
+ send_xembed_message (socket, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT, 0, 0,
+ gtk_get_current_event_time ());
+ }
}
return TRUE;
}
-static gint
+static gboolean
gtk_socket_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
{
- GtkWidget *toplevel;
- GtkSocket *socket;
+ GtkSocket *socket = GTK_SOCKET (widget);
- g_return_val_if_fail (GTK_IS_SOCKET (widget), FALSE);
- socket = GTK_SOCKET (widget);
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
- toplevel = gtk_widget_get_ancestor (widget, gtk_window_get_type());
+#if 0
+ GtkWidget *toplevel;
+ toplevel = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
if (toplevel)
{
RevertToParent, CurrentTime); /* FIXME? */
}
- socket->focus_in = FALSE;
+#endif
+
+ if (socket->plug_window)
+ {
+ send_xembed_message (socket, XEMBED_FOCUS_OUT, 0, 0, 0,
+ gtk_get_current_event_time ());
+ }
+ socket->focus_in = FALSE;
+
return TRUE;
}
* it as an app... (and see _focus_in ()) */
if (socket->plug_window)
{
+#if 0
gdk_error_trap_push ();
XSetInputFocus (GDK_DISPLAY (),
GDK_WINDOW_XWINDOW (socket->plug_window),
RevertToParent, GDK_CURRENT_TIME);
gdk_flush ();
gdk_error_trap_pop ();
+#endif
}
}
-static gint
+static gboolean
gtk_socket_focus (GtkContainer *container, GtkDirectionType direction)
{
GtkSocket *socket;
+ gint detail = -1;
g_return_val_if_fail (GTK_IS_SOCKET (container), FALSE);
socket = GTK_SOCKET (container);
+ if (!GTK_WIDGET_HAS_FOCUS (container))
+ {
+ 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;
+ }
+
+ send_xembed_message (socket, XEMBED_FOCUS_IN, detail, 0, 0,
+ gtk_get_current_event_time ());
+
+ GTK_WIDGET_SET_FLAGS (container, GTK_HAS_FOCUS);
+ gtk_widget_grab_focus (GTK_WIDGET (container));
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+
+#if 0
if (!socket->focus_in && socket->plug_window)
{
XEvent xevent;
{
return FALSE;
}
+#endif
}
static void
}
static void
-gtk_socket_add_window (GtkSocket *socket, guint32 xid)
+gtk_socket_add_window (GtkSocket *socket, GdkNativeWindow xid)
{
socket->plug_window = gdk_window_lookup (xid);
socket->same_app = TRUE;
{
gtk_window_add_embedded_xid (GTK_WINDOW (toplevel), xid);
}
+
+ gtk_widget_queue_resize (GTK_WIDGET (socket));
+ }
+}
+
+
+static void
+send_xembed_message (GtkSocket *socket,
+ glong message,
+ glong detail,
+ glong data1,
+ glong data2,
+ guint32 time)
+{
+ GTK_NOTE(PLUGSOCKET,
+ g_message ("GtkSocket: Sending XEMBED message of type %d", message));
+
+ if (socket->plug_window)
+ {
+ XEvent xevent;
+
+ xevent.xclient.window = GDK_WINDOW_XWINDOW (socket->plug_window);
+ xevent.xclient.type = ClientMessage;
+ xevent.xclient.message_type = gdk_atom_intern ("_XEMBED", FALSE);
+ xevent.xclient.format = 32;
+ xevent.xclient.data.l[0] = time;
+ xevent.xclient.data.l[1] = message;
+ xevent.xclient.data.l[2] = detail;
+ xevent.xclient.data.l[3] = data1;
+ xevent.xclient.data.l[4] = data2;
+
+ gdk_error_trap_push ();
+ XSendEvent (gdk_display,
+ GDK_WINDOW_XWINDOW (socket->plug_window),
+ False, NoEventMask, &xevent);
+ gdk_flush ();
+ gdk_error_trap_pop ();
+ }
+}
+
+static void
+handle_xembed_message (GtkSocket *socket,
+ glong message,
+ glong detail,
+ glong data1,
+ glong data2,
+ guint32 time)
+{
+ 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 of type %ld received", message);
+ break;
+
+ case XEMBED_REQUEST_FOCUS:
+ gtk_socket_claim_focus (socket);
+ break;
+
+ case XEMBED_FOCUS_NEXT:
+ case XEMBED_FOCUS_PREV:
+ {
+ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
+ if (toplevel && GTK_IS_CONTAINER (toplevel))
+ {
+ gtk_container_focus (GTK_CONTAINER (toplevel),
+ (message == XEMBED_FOCUS_NEXT ?
+ GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD));
+ }
+ break;
+ }
+
+ case XEMBED_GRAB_KEY:
+#if 0
+ add_grabbed_key (socket, data1, data2);
+#endif
+ break;
+ case XEMBED_UNGRAB_KEY:
+#if 0
+ remove_grabbed_key (socket, data1, data2);
+#endif
+ break;
+
+ default:
+ GTK_NOTE(PLUGSOCKET,
+ g_message ("GtkSocket: Ignoring unknown _XEMBED message of type %ld", message));
+ break;
}
}
g_message ("GtkSocket - window created with size: %d %d",
socket->request_width,
socket->request_height));
-
- gtk_widget_queue_resize (widget);
}
return_val = GDK_FILTER_REMOVE;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
if (toplevel && GTK_IS_WINDOW (toplevel))
gtk_window_remove_embedded_xid (GTK_WINDOW (toplevel), xdwe->window);
+
gdk_window_destroy_notify (socket->plug_window);
gtk_widget_destroy (widget);
return_val = GDK_FILTER_REMOVE;
}
break;
- }
-
+ }
+
case FocusIn:
if (xevent->xfocus.mode == EMBEDDED_APP_WANTS_FOCUS)
{
{
#if 0
GtkWidget *toplevel;
- toplevel = gtk_widget_get_ancestor (widget, gtk_window_get_type());
+ toplevel = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
if (toplevel)
{
{
GTK_NOTE(PLUGSOCKET,
g_message ("GtkSocket - Map Request"));
-
+
gdk_error_trap_push ();
gdk_window_show (socket->plug_window);
gdk_flush ();
}
return_val = GDK_FILTER_REMOVE;
}
+ break;
+ case ClientMessage:
+ if (xevent->xclient.message_type == gdk_atom_intern ("_XEMBED", FALSE))
+ {
+ 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]);
+
+
+ return_val = GDK_FILTER_REMOVE;
+ }
+ break;
}
-
+
return return_val;
}
-#elif defined (GDK_WINDOWING_WIN32)
+#else
-guint
-gtk_socket_get_type ()
+GtkType
+gtk_socket_get_type (void)
{
g_error ("GtkSocket not implemented");
- return 42;
+ return 0;
}
GtkWidget*
}
void
-gtk_socket_steal (GtkSocket *socket, guint32 id)
+gtk_socket_steal (GtkSocket *socket, GdkNativeWindow id)
{
g_error ("GtkSocket not implemented");
}
projects / ~andy / gtk / blobdiff