Pileus Git - ~andy/gtk/blob - gtk/gtksocket.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 /* By Owen Taylor <otaylor@gtk.org>              98/4/4 */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include "config.h"
  29 #include <string.h>
  30
  31 #include "gdk/gdkkeysyms.h"
  32 #include "gtkmain.h"
  33 #include "gtkmarshalers.h"
  34 #include "gtkwindow.h"
  35 #include "gtkplug.h"
  36 #include "gtkprivate.h"
  37 #include "gtksocket.h"
  38 #include "gtksocketprivate.h"
  39 #include "gtkdnd.h"
  40 #include "gtkintl.h"
  41
  42 #include "gtkalias.h"
  43
  44 /* Forward declararations */
  45
  46 static void     gtk_socket_finalize             (GObject          *object);
  47 static void     gtk_socket_notify               (GObject          *object,
  48                                                  GParamSpec       *pspec);
  49 static void     gtk_socket_realize              (GtkWidget        *widget);
  50 static void     gtk_socket_unrealize            (GtkWidget        *widget);
  51 static void     gtk_socket_size_request         (GtkWidget        *widget,
  52                                                  GtkRequisition   *requisition);
  53 static void     gtk_socket_size_allocate        (GtkWidget        *widget,
  54                                                  GtkAllocation    *allocation);
  55 static void     gtk_socket_hierarchy_changed    (GtkWidget        *widget,
  56                                                  GtkWidget        *old_toplevel);
  57 static void     gtk_socket_grab_notify          (GtkWidget        *widget,
  58                                                  gboolean          was_grabbed);
  59 static gboolean gtk_socket_key_event            (GtkWidget        *widget,
  60                                                  GdkEventKey      *event);
  61 static gboolean gtk_socket_focus                (GtkWidget        *widget,
  62                                                  GtkDirectionType  direction);
  63 static void     gtk_socket_remove               (GtkContainer     *container,
  64                                                  GtkWidget        *widget);
  65 static void     gtk_socket_forall               (GtkContainer     *container,
  66                                                  gboolean          include_internals,
  67                                                  GtkCallback       callback,
  68                                                  gpointer          callback_data);
  69
  70
  71 /* Local data */
  72
  73 typedef struct
  74 {
  75   guint                  accel_key;
  76   GdkModifierType        accel_mods;
  77 } GrabbedKey;
  78
  79 enum {
  80   PLUG_ADDED,
  81   PLUG_REMOVED,
  82   LAST_SIGNAL
  83 };
  84
  85 static guint socket_signals[LAST_SIGNAL] = { 0 };
  86
  87 /*
  88  * _gtk_socket_get_private:
  89  *
  90  * @socket: a #GtkSocket
  91  *
  92  * Returns the private data associated with a GtkSocket, creating it
  93  * first if necessary.
  94  */
  95 GtkSocketPrivate *
  96 _gtk_socket_get_private (GtkSocket *socket)
  97 {
  98   return G_TYPE_INSTANCE_GET_PRIVATE (socket, GTK_TYPE_SOCKET, GtkSocketPrivate);
  99 }
 100
 101 G_DEFINE_TYPE (GtkSocket, gtk_socket, GTK_TYPE_CONTAINER)
 102
 103 static void
 104 gtk_socket_finalize (GObject *object)
 105 {
 106   GtkSocket *socket = GTK_SOCKET (object);
 107
 108   g_object_unref (socket->accel_group);
 109   socket->accel_group = NULL;
 110
 111   G_OBJECT_CLASS (gtk_socket_parent_class)->finalize (object);
 112 }
 113
 114 static void
 115 gtk_socket_class_init (GtkSocketClass *class)
 116 {
 117   GtkWidgetClass *widget_class;
 118   GtkContainerClass *container_class;
 119   GObjectClass *gobject_class;
 120
 121   gobject_class = (GObjectClass *) class;
 122   widget_class = (GtkWidgetClass*) class;
 123   container_class = (GtkContainerClass*) class;
 124
 125   gobject_class->finalize = gtk_socket_finalize;
 126   gobject_class->notify = gtk_socket_notify;
 127
 128   widget_class->realize = gtk_socket_realize;
 129   widget_class->unrealize = gtk_socket_unrealize;
 130   widget_class->size_request = gtk_socket_size_request;
 131   widget_class->size_allocate = gtk_socket_size_allocate;
 132   widget_class->hierarchy_changed = gtk_socket_hierarchy_changed;
 133   widget_class->grab_notify = gtk_socket_grab_notify;
 134   widget_class->key_press_event = gtk_socket_key_event;
 135   widget_class->key_release_event = gtk_socket_key_event;
 136   widget_class->focus = gtk_socket_focus;
 137
 138   /* We don't want to show_all/hide_all the in-process
 139    * plug, if any.
 140    */
 141   widget_class->show_all = gtk_widget_show;
 142   widget_class->hide_all = gtk_widget_hide;
 143
 144   container_class->remove = gtk_socket_remove;
 145   container_class->forall = gtk_socket_forall;
 146
 147   /**
 148    * GtkSocket::plug-added:
 149    * @socket_: the object which received the signal
 150    *
 151    * This signal is emitted when a client is successfully
 152    * added to the socket.
 153    */
 154   socket_signals[PLUG_ADDED] =
 155     g_signal_new (I_("plug-added"),
 156                   G_OBJECT_CLASS_TYPE (class),
 157                   G_SIGNAL_RUN_LAST,
 158                   G_STRUCT_OFFSET (GtkSocketClass, plug_added),
 159                   NULL, NULL,
 160                   _gtk_marshal_VOID__VOID,
 161                   G_TYPE_NONE, 0);
 162
 163   /**
 164    * GtkSocket::plug-removed:
 165    * @socket_: the object which received the signal
 166    *
 167    * This signal is emitted when a client is removed from the socket.
 168    * The default action is to destroy the #GtkSocket widget, so if you
 169    * want to reuse it you must add a signal handler that returns %TRUE.
 170    *
 171    * Return value: %TRUE to stop other handlers from being invoked.
 172    */
 173   socket_signals[PLUG_REMOVED] =
 174     g_signal_new (I_("plug-removed"),
 175                   G_OBJECT_CLASS_TYPE (class),
 176                   G_SIGNAL_RUN_LAST,
 177                   G_STRUCT_OFFSET (GtkSocketClass, plug_removed),
 178                   _gtk_boolean_handled_accumulator, NULL,
 179                   _gtk_marshal_BOOLEAN__VOID,
 180                   G_TYPE_BOOLEAN, 0);
 181
 182   g_type_class_add_private (gobject_class, sizeof (GtkSocketPrivate));
 183 }
 184
 185 static void
 186 gtk_socket_init (GtkSocket *socket)
 187 {
 188   socket->request_width = 0;
 189   socket->request_height = 0;
 190   socket->current_width = 0;
 191   socket->current_height = 0;
 192
 193   socket->plug_window = NULL;
 194   socket->plug_widget = NULL;
 195   socket->focus_in = FALSE;
 196   socket->have_size = FALSE;
 197   socket->need_map = FALSE;
 198   socket->active = FALSE;
 199
 200   socket->accel_group = gtk_accel_group_new ();
 201   g_object_set_data (G_OBJECT (socket->accel_group), I_("gtk-socket"), socket);
 202 }
 203
 204 /**
 205  * gtk_socket_new:
 206  *
 207  * Create a new empty #GtkSocket.
 208  *
 209  * Return value:  the new #GtkSocket.
 210  **/
 211 GtkWidget*
 212 gtk_socket_new (void)
 213 {
 214   GtkSocket *socket;
 215
 216   socket = g_object_new (GTK_TYPE_SOCKET, NULL);
 217
 218   return GTK_WIDGET (socket);
 219 }
 220
 221 /**
 222  * gtk_socket_steal:
 223  * @socket_: a #GtkSocket
 224  * @wid: the window ID of an existing toplevel window.
 225  *
 226  * Reparents a pre-existing toplevel window into a #GtkSocket. This is
 227  * meant to embed clients that do not know about embedding into a
 228  * #GtkSocket, however doing so is inherently unreliable, and using
 229  * this function is not recommended.
 230  *
 231  * The #GtkSocket must have already be added into a toplevel window
 232  *  before you can make this call.
 233  **/
 234 void
 235 gtk_socket_steal (GtkSocket      *socket,
 236                   GdkNativeWindow wid)
 237 {
 238   g_return_if_fail (GTK_IS_SOCKET (socket));
 239   g_return_if_fail (GTK_WIDGET_ANCHORED (socket));
 240
 241   if (!GTK_WIDGET_REALIZED (socket))
 242     gtk_widget_realize (GTK_WIDGET (socket));
 243
 244   _gtk_socket_add_window (socket, wid, TRUE);
 245 }
 246
 247 /**
 248  * gtk_socket_add_id:
 249  * @socket_: a #GtkSocket
 250  * @window_id: the window ID of a client participating in the XEMBED protocol.
 251  *
 252  * Adds an XEMBED client, such as a #GtkPlug, to the #GtkSocket.  The
 253  * client may be in the same process or in a different process.
 254  *
 255  * To embed a #GtkPlug in a #GtkSocket, you can either create the
 256  * #GtkPlug with <literal>gtk_plug_new (0)</literal>, call
 257  * gtk_plug_get_id() to get the window ID of the plug, and then pass that to the
 258  * gtk_socket_add_id(), or you can call gtk_socket_get_id() to get the
 259  * window ID for the socket, and call gtk_plug_new() passing in that
 260  * ID.
 261  *
 262  * The #GtkSocket must have already be added into a toplevel window
 263  *  before you can make this call.
 264  **/
 265 void
 266 gtk_socket_add_id (GtkSocket      *socket,
 267                    GdkNativeWindow window_id)
 268 {
 269   g_return_if_fail (GTK_IS_SOCKET (socket));
 270   g_return_if_fail (GTK_WIDGET_ANCHORED (socket));
 271
 272   if (!GTK_WIDGET_REALIZED (socket))
 273     gtk_widget_realize (GTK_WIDGET (socket));
 274
 275   _gtk_socket_add_window (socket, window_id, TRUE);
 276 }
 277
 278 /**
 279  * gtk_socket_get_id:
 280  * @socket_: a #GtkSocket.
 281  *
 282  * Gets the window ID of a #GtkSocket widget, which can then
 283  * be used to create a client embedded inside the socket, for
 284  * instance with gtk_plug_new().
 285  *
 286  * The #GtkSocket must have already be added into a toplevel window
 287  * before you can make this call.
 288  *
 289  * Return value: the window ID for the socket
 290  **/
 291 GdkNativeWindow
 292 gtk_socket_get_id (GtkSocket *socket)
 293 {
 294   g_return_val_if_fail (GTK_IS_SOCKET (socket), 0);
 295   g_return_val_if_fail (GTK_WIDGET_ANCHORED (socket), 0);
 296
 297   if (!GTK_WIDGET_REALIZED (socket))
 298     gtk_widget_realize (GTK_WIDGET (socket));
 299
 300   return _gtk_socket_windowing_get_id (socket);
 301 }
 302
 303 /**
 304  * gtk_socket_get_plug_window:
 305  * @socket_: a #GtkSocket.
 306  *
 307  * Retrieves the window of the plug. Use this to check if the plug has
 308  * been created inside of the socket.
 309  *
 310  * Return value: the window of the plug if available, or %NULL
 311  *
 312  * Since:  2.14
 313  **/
 314 GdkWindow*
 315 gtk_socket_get_plug_window (GtkSocket *socket)
 316 {
 317   g_return_val_if_fail (GTK_IS_SOCKET (socket), NULL);
 318
 319   return socket->plug_window;
 320 }
 321
 322 static void
 323 gtk_socket_realize (GtkWidget *widget)
 324 {
 325   GtkSocket *socket = GTK_SOCKET (widget);
 326   GdkWindowAttr attributes;
 327   gint attributes_mask;
 328
 329   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 330
 331   attributes.window_type = GDK_WINDOW_CHILD;
 332   attributes.x = widget->allocation.x;
 333   attributes.y = widget->allocation.y;
 334   attributes.width = widget->allocation.width;
 335   attributes.height = widget->allocation.height;
 336   attributes.wclass = GDK_INPUT_OUTPUT;
 337   attributes.visual = gtk_widget_get_visual (widget);
 338   attributes.colormap = gtk_widget_get_colormap (widget);
 339   attributes.event_mask = GDK_FOCUS_CHANGE_MASK;
 340
 341   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 342
 343   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 344                                    &attributes, attributes_mask);
 345   gdk_window_set_user_data (widget->window, socket);
 346
 347   widget->style = gtk_style_attach (widget->style, widget->window);
 348   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 349
 350   _gtk_socket_windowing_realize_window (socket);
 351
 352   gdk_window_add_filter (widget->window,
 353                          _gtk_socket_windowing_filter_func,
 354                          widget);
 355
 356   /* We sync here so that we make sure that if the XID for
 357    * our window is passed to another application, SubstructureRedirectMask
 358    * will be set by the time the other app creates its window.
 359    */
 360   gdk_display_sync (gtk_widget_get_display (widget));
 361 }
 362
 363 /**
 364  * _gtk_socket_end_embedding:
 365  *
 366  * @socket: a #GtkSocket
 367  *
 368  * Called to end the embedding of a plug in the socket.
 369  */
 370 void
 371 _gtk_socket_end_embedding (GtkSocket *socket)
 372 {
 373   GtkSocketPrivate *private = _gtk_socket_get_private (socket);
 374   GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 375   gint i;
 376
 377   if (GTK_IS_WINDOW (toplevel))
 378     _gtk_socket_windowing_end_embedding_toplevel (socket);
 379
 380   g_object_unref (socket->plug_window);
 381   socket->plug_window = NULL;
 382   socket->current_width = 0;
 383   socket->current_height = 0;
 384   private->resize_count = 0;
 385
 386   /* Remove from end to avoid indexes shifting. This is evil */
 387   for (i = socket->accel_group->n_accels - 1; i >= 0; i--)
 388     {
 389       GtkAccelGroupEntry *accel_entry = &socket->accel_group->priv_accels[i];
 390       gtk_accel_group_disconnect (socket->accel_group, accel_entry->closure);
 391     }
 392 }
 393
 394 static void
 395 gtk_socket_unrealize (GtkWidget *widget)
 396 {
 397   GtkSocket *socket = GTK_SOCKET (widget);
 398
 399   GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED);
 400
 401   if (socket->plug_widget)
 402     {
 403       _gtk_plug_remove_from_socket (GTK_PLUG (socket->plug_widget), socket);
 404     }
 405   else if (socket->plug_window)
 406     {
 407       _gtk_socket_end_embedding (socket);
 408     }
 409
 410   GTK_WIDGET_CLASS (gtk_socket_parent_class)->unrealize (widget);
 411 }
 412
 413 static void
 414 gtk_socket_size_request (GtkWidget      *widget,
 415                          GtkRequisition *requisition)
 416 {
 417   GtkSocket *socket = GTK_SOCKET (widget);
 418
 419   if (socket->plug_widget)
 420     {
 421       gtk_widget_size_request (socket->plug_widget, requisition);
 422     }
 423   else
 424     {
 425       if (socket->is_mapped && !socket->have_size && socket->plug_window)
 426         _gtk_socket_windowing_size_request (socket);
 427
 428       if (socket->is_mapped && socket->have_size)
 429         {
 430           requisition->width = MAX (socket->request_width, 1);
 431           requisition->height = MAX (socket->request_height, 1);
 432         }
 433       else
 434         {
 435           requisition->width = 1;
 436           requisition->height = 1;
 437         }
 438     }
 439 }
 440
 441 static void
 442 gtk_socket_size_allocate (GtkWidget     *widget,
 443                           GtkAllocation *allocation)
 444 {
 445   GtkSocket *socket = GTK_SOCKET (widget);
 446
 447   widget->allocation = *allocation;
 448   if (GTK_WIDGET_REALIZED (widget))
 449     {
 450       gdk_window_move_resize (widget->window,
 451                               allocation->x, allocation->y,
 452                               allocation->width, allocation->height);
 453
 454       if (socket->plug_widget)
 455         {
 456           GtkAllocation child_allocation;
 457
 458           child_allocation.x = 0;
 459           child_allocation.y = 0;
 460           child_allocation.width = allocation->width;
 461           child_allocation.height = allocation->height;
 462
 463           gtk_widget_size_allocate (socket->plug_widget, &child_allocation);
 464         }
 465       else if (socket->plug_window)
 466         {
 467           GtkSocketPrivate *private = _gtk_socket_get_private (socket);
 468
 469           gdk_error_trap_push ();
 470
 471           if (allocation->width != socket->current_width ||
 472               allocation->height != socket->current_height)
 473             {
 474               gdk_window_move_resize (socket->plug_window,
 475                                       0, 0,
 476                                       allocation->width, allocation->height);
 477               if (private->resize_count)
 478                 private->resize_count--;
 479
 480               GTK_NOTE (PLUGSOCKET,
 481                         g_message ("GtkSocket - allocated: %d %d",
 482                                    allocation->width, allocation->height));
 483               socket->current_width = allocation->width;
 484               socket->current_height = allocation->height;
 485             }
 486
 487           if (socket->need_map)
 488             {
 489               gdk_window_show (socket->plug_window);
 490               socket->need_map = FALSE;
 491             }
 492
 493           while (private->resize_count)
 494             {
 495               _gtk_socket_windowing_send_configure_event (socket);
 496               private->resize_count--;
 497               GTK_NOTE (PLUGSOCKET,
 498                         g_message ("GtkSocket - sending synthetic configure: %d %d",
 499                                    allocation->width, allocation->height));
 500             }
 501
 502           gdk_display_sync (gtk_widget_get_display (widget));
 503           gdk_error_trap_pop ();
 504         }
 505     }
 506 }
 507
 508 static gboolean
 509 activate_key (GtkAccelGroup  *accel_group,
 510               GObject        *acceleratable,
 511               guint           accel_key,
 512               GdkModifierType accel_mods,
 513               GrabbedKey     *grabbed_key)
 514 {
 515   GdkEvent *gdk_event = gtk_get_current_event ();
 516
 517   GtkSocket *socket = g_object_get_data (G_OBJECT (accel_group), "gtk-socket");
 518   gboolean retval = FALSE;
 519
 520   if (gdk_event && gdk_event->type == GDK_KEY_PRESS && socket->plug_window)
 521     {
 522       _gtk_socket_windowing_send_key_event (socket, gdk_event, TRUE);
 523       retval = TRUE;
 524     }
 525
 526   if (gdk_event)
 527     gdk_event_free (gdk_event);
 528
 529   return retval;
 530 }
 531
 532 static gboolean
 533 find_accel_key (GtkAccelKey *key,
 534                 GClosure    *closure,
 535                 gpointer     data)
 536 {
 537   GrabbedKey *grabbed_key = data;
 538
 539   return (key->accel_key == grabbed_key->accel_key &&
 540           key->accel_mods == grabbed_key->accel_mods);
 541 }
 542
 543 /**
 544  * _gtk_socket_add_grabbed_key:
 545  *
 546  * @socket: a #GtkSocket
 547  * @keyval: a key
 548  * @modifiers: modifiers for the key
 549  *
 550  * Called from the GtkSocket platform-specific backend when the
 551  * corresponding plug has told the socket to grab a key.
 552  */
 553 void
 554 _gtk_socket_add_grabbed_key (GtkSocket       *socket,
 555                              guint            keyval,
 556                              GdkModifierType  modifiers)
 557 {
 558   GClosure *closure;
 559   GrabbedKey *grabbed_key;
 560
 561   grabbed_key = g_new (GrabbedKey, 1);
 562
 563   grabbed_key->accel_key = keyval;
 564   grabbed_key->accel_mods = modifiers;
 565
 566   if (gtk_accel_group_find (socket->accel_group,
 567                             find_accel_key,
 568                             &grabbed_key))
 569     {
 570       g_warning ("GtkSocket: request to add already present grabbed key %u,%#x\n",
 571                  keyval, modifiers);
 572       g_free (grabbed_key);
 573       return;
 574     }
 575
 576   closure = g_cclosure_new (G_CALLBACK (activate_key), grabbed_key, (GClosureNotify)g_free);
 577
 578   gtk_accel_group_connect (socket->accel_group, keyval, modifiers, GTK_ACCEL_LOCKED,
 579                            closure);
 580 }
 581
 582 /**
 583  * _gtk_socket_remove_grabbed_key:
 584  *
 585  * @socket: a #GtkSocket
 586  * @keyval: a key
 587  * @modifiers: modifiers for the key
 588  *
 589  * Called from the GtkSocket backend when the corresponding plug has
 590  * told the socket to remove a key grab.
 591  */
 592 void
 593 _gtk_socket_remove_grabbed_key (GtkSocket      *socket,
 594                                 guint           keyval,
 595                                 GdkModifierType modifiers)
 596 {
 597   gint i;
 598
 599   for (i = 0; i < socket->accel_group->n_accels; i++)
 600     {
 601       GtkAccelGroupEntry *accel_entry = &socket->accel_group->priv_accels[i];
 602       if (accel_entry->key.accel_key == keyval &&
 603           accel_entry->key.accel_mods == modifiers)
 604         {
 605           gtk_accel_group_disconnect (socket->accel_group,
 606                                       accel_entry->closure);
 607           return;
 608         }
 609     }
 610
 611   g_warning ("GtkSocket: request to remove non-present grabbed key %u,%#x\n",
 612              keyval, modifiers);
 613 }
 614
 615 static void
 616 socket_update_focus_in (GtkSocket *socket)
 617 {
 618   gboolean focus_in = FALSE;
 619
 620   if (socket->plug_window)
 621     {
 622       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 623
 624       if (GTK_WIDGET_TOPLEVEL (toplevel) &&
 625           GTK_WINDOW (toplevel)->has_toplevel_focus &&
 626           gtk_widget_is_focus (GTK_WIDGET (socket)))
 627         focus_in = TRUE;
 628     }
 629
 630   if (focus_in != socket->focus_in)
 631     {
 632       socket->focus_in = focus_in;
 633
 634       _gtk_socket_windowing_focus_change (socket, focus_in);
 635     }
 636 }
 637
 638 static void
 639 socket_update_active (GtkSocket *socket)
 640 {
 641   gboolean active = FALSE;
 642
 643   if (socket->plug_window)
 644     {
 645       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 646
 647       if (GTK_WIDGET_TOPLEVEL (toplevel) &&
 648           GTK_WINDOW (toplevel)->is_active)
 649         active = TRUE;
 650     }
 651
 652   if (active != socket->active)
 653     {
 654       socket->active = active;
 655
 656       _gtk_socket_windowing_update_active (socket, active);
 657     }
 658 }
 659
 660 static void
 661 gtk_socket_hierarchy_changed (GtkWidget *widget,
 662                               GtkWidget *old_toplevel)
 663 {
 664   GtkSocket *socket = GTK_SOCKET (widget);
 665   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
 666
 667   if (toplevel && !GTK_IS_WINDOW (toplevel))
 668     toplevel = NULL;
 669
 670   if (toplevel != socket->toplevel)
 671     {
 672       if (socket->toplevel)
 673         {
 674           gtk_window_remove_accel_group (GTK_WINDOW (socket->toplevel), socket->accel_group);
 675           g_signal_handlers_disconnect_by_func (socket->toplevel,
 676                                                 socket_update_focus_in,
 677                                                 socket);
 678           g_signal_handlers_disconnect_by_func (socket->toplevel,
 679                                                 socket_update_active,
 680                                                 socket);
 681         }
 682
 683       socket->toplevel = toplevel;
 684
 685       if (toplevel)
 686         {
 687           gtk_window_add_accel_group (GTK_WINDOW (socket->toplevel), socket->accel_group);
 688           g_signal_connect_swapped (socket->toplevel, "notify::has-toplevel-focus",
 689                                     G_CALLBACK (socket_update_focus_in), socket);
 690           g_signal_connect_swapped (socket->toplevel, "notify::is-active",
 691                                     G_CALLBACK (socket_update_active), socket);
 692         }
 693
 694       socket_update_focus_in (socket);
 695       socket_update_active (socket);
 696     }
 697 }
 698
 699 static void
 700 gtk_socket_grab_notify (GtkWidget *widget,
 701                         gboolean   was_grabbed)
 702 {
 703   GtkSocket *socket = GTK_SOCKET (widget);
 704
 705   if (!socket->same_app)
 706     _gtk_socket_windowing_update_modality (socket, !was_grabbed);
 707 }
 708
 709 static gboolean
 710 gtk_socket_key_event (GtkWidget   *widget,
 711                       GdkEventKey *event)
 712 {
 713   GtkSocket *socket = GTK_SOCKET (widget);
 714
 715   if (GTK_WIDGET_HAS_FOCUS (socket) && socket->plug_window && !socket->plug_widget)
 716     {
 717       _gtk_socket_windowing_send_key_event (socket, (GdkEvent *) event, FALSE);
 718
 719       return TRUE;
 720     }
 721   else
 722     return FALSE;
 723 }
 724
 725 static void
 726 gtk_socket_notify (GObject    *object,
 727                    GParamSpec *pspec)
 728 {
 729   if (!strcmp (pspec->name, "is-focus"))
 730     return;
 731   socket_update_focus_in (GTK_SOCKET (object));
 732 }
 733
 734 /**
 735  * _gtk_socket_claim_focus:
 736  *
 737  * @socket: a #GtkSocket
 738  * @send_event: huh?
 739  *
 740  * Claims focus for the socket. XXX send_event?
 741  */
 742 void
 743 _gtk_socket_claim_focus (GtkSocket *socket,
 744                          gboolean   send_event)
 745 {
 746   if (!send_event)
 747     socket->focus_in = TRUE;    /* Otherwise, our notify handler will send FOCUS_IN  */
 748
 749   /* Oh, the trickery... */
 750
 751   GTK_WIDGET_SET_FLAGS (socket, GTK_CAN_FOCUS);
 752   gtk_widget_grab_focus (GTK_WIDGET (socket));
 753   GTK_WIDGET_UNSET_FLAGS (socket, GTK_CAN_FOCUS);
 754 }
 755
 756 static gboolean
 757 gtk_socket_focus (GtkWidget       *widget,
 758                   GtkDirectionType direction)
 759 {
 760   GtkSocket *socket = GTK_SOCKET (widget);
 761
 762   if (socket->plug_widget)
 763     return gtk_widget_child_focus (socket->plug_widget, direction);
 764
 765   if (!gtk_widget_is_focus (widget))
 766     {
 767       _gtk_socket_windowing_focus (socket, direction);
 768       _gtk_socket_claim_focus (socket, FALSE);
 769
 770       return TRUE;
 771     }
 772   else
 773     return FALSE;
 774 }
 775
 776 static void
 777 gtk_socket_remove (GtkContainer *container,
 778                    GtkWidget    *child)
 779 {
 780   GtkSocket *socket = GTK_SOCKET (container);
 781
 782   g_return_if_fail (child == socket->plug_widget);
 783
 784   _gtk_plug_remove_from_socket (GTK_PLUG (socket->plug_widget), socket);
 785 }
 786
 787 static void
 788 gtk_socket_forall (GtkContainer *container,
 789                    gboolean      include_internals,
 790                    GtkCallback   callback,
 791                    gpointer      callback_data)
 792 {
 793   GtkSocket *socket = GTK_SOCKET (container);
 794
 795   if (socket->plug_widget)
 796     (* callback) (socket->plug_widget, callback_data);
 797 }
 798
 799 /**
 800  * _gtk_socket_add_window:
 801  *
 802  * @socket: a #GtkSocket
 803  * @xid: the native identifier for a window
 804  * @need_reparent: whether the socket's plug's window needs to be
 805  *                 reparented to the socket
 806  *
 807  * Adds a window to a GtkSocket.
 808  */
 809 void
 810 _gtk_socket_add_window (GtkSocket       *socket,
 811                         GdkNativeWindow  xid,
 812                         gboolean         need_reparent)
 813 {
 814   GtkWidget *widget = GTK_WIDGET (socket);
 815   GdkDisplay *display = gtk_widget_get_display (widget);
 816   gpointer user_data = NULL;
 817
 818   socket->plug_window = gdk_window_lookup_for_display (display, xid);
 819
 820   if (socket->plug_window)
 821     {
 822       g_object_ref (socket->plug_window);
 823       gdk_window_get_user_data (socket->plug_window, &user_data);
 824     }
 825
 826   if (user_data)                /* A widget's window in this process */
 827     {
 828       GtkWidget *child_widget = user_data;
 829
 830       if (!GTK_IS_PLUG (child_widget))
 831         {
 832           g_warning (G_STRLOC ": Can't add non-GtkPlug to GtkSocket");
 833           socket->plug_window = NULL;
 834           gdk_error_trap_pop ();
 835
 836           return;
 837         }
 838
 839       _gtk_plug_add_to_socket (GTK_PLUG (child_widget), socket);
 840     }
 841   else                          /* A foreign window */
 842     {
 843       GtkWidget *toplevel;
 844       GdkDragProtocol protocol;
 845
 846       gdk_error_trap_push ();
 847
 848       if (!socket->plug_window)
 849         {
 850           socket->plug_window = gdk_window_foreign_new_for_display (display, xid);
 851           if (!socket->plug_window) /* was deleted before we could get it */
 852             {
 853               gdk_error_trap_pop ();
 854               return;
 855             }
 856         }
 857
 858       _gtk_socket_windowing_select_plug_window_input (socket);
 859
 860       if (gdk_error_trap_pop ())
 861         {
 862           g_object_unref (socket->plug_window);
 863           socket->plug_window = NULL;
 864           return;
 865         }
 866
 867       /* OK, we now will reliably get destroy notification on socket->plug_window */
 868
 869       gdk_error_trap_push ();
 870
 871       if (need_reparent)
 872         {
 873           gdk_window_hide (socket->plug_window); /* Shouldn't actually be necessary for XEMBED, but just in case */
 874           gdk_window_reparent (socket->plug_window, widget->window, 0, 0);
 875         }
 876
 877       socket->have_size = FALSE;
 878
 879       _gtk_socket_windowing_embed_get_info (socket);
 880
 881       socket->need_map = socket->is_mapped;
 882
 883       if (gdk_drag_get_protocol_for_display (display, xid, &protocol))
 884         gtk_drag_dest_set_proxy (GTK_WIDGET (socket), socket->plug_window,
 885                                  protocol, TRUE);
 886
 887       gdk_display_sync (display);
 888       gdk_error_trap_pop ();
 889
 890       gdk_window_add_filter (socket->plug_window,
 891                              _gtk_socket_windowing_filter_func,
 892                              socket);
 893
 894       /* Add a pointer to the socket on our toplevel window */
 895
 896       toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 897       if (GTK_IS_WINDOW (toplevel))
 898         gtk_window_add_embedded_xid (GTK_WINDOW (toplevel), xid);
 899
 900       _gtk_socket_windowing_embed_notify (socket);
 901
 902       socket_update_active (socket);
 903       socket_update_focus_in (socket);
 904
 905       gtk_widget_queue_resize (GTK_WIDGET (socket));
 906     }
 907
 908   if (socket->plug_window)
 909     g_signal_emit (socket, socket_signals[PLUG_ADDED], 0);
 910 }
 911
 912 /**
 913  * _gtk_socket_handle_map_request:
 914  *
 915  * @socket: a #GtkSocket
 916  *
 917  * Called from the GtkSocket backend when the plug has been mapped.
 918  */
 919 void
 920 _gtk_socket_handle_map_request (GtkSocket *socket)
 921 {
 922   if (!socket->is_mapped)
 923     {
 924       socket->is_mapped = TRUE;
 925       socket->need_map = TRUE;
 926
 927       gtk_widget_queue_resize (GTK_WIDGET (socket));
 928     }
 929 }
 930
 931 /**
 932  * _gtk_socket_unmap_notify:
 933  *
 934  * @socket: a #GtkSocket
 935  *
 936  * Called from the GtkSocket backend when the plug has been unmapped ???
 937  */
 938 void
 939 _gtk_socket_unmap_notify (GtkSocket *socket)
 940 {
 941   if (socket->is_mapped)
 942     {
 943       socket->is_mapped = FALSE;
 944       gtk_widget_queue_resize (GTK_WIDGET (socket));
 945     }
 946 }
 947
 948 /**
 949  * _gtk_socket_advance_toplevel_focus:
 950  *
 951  * @socket: a #GtkSocket
 952  * @direction: a direction
 953  *
 954  * Called from the GtkSocket backend when the corresponding plug
 955  * has told the socket to move the focus.
 956  */
 957 void
 958 _gtk_socket_advance_toplevel_focus (GtkSocket        *socket,
 959                                     GtkDirectionType  direction)
 960 {
 961   GtkBin *bin;
 962   GtkWindow *window;
 963   GtkContainer *container;
 964   GtkWidget *toplevel;
 965   GtkWidget *old_focus_child;
 966   GtkWidget *parent;
 967
 968   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 969   if (!toplevel)
 970     return;
 971
 972   if (!GTK_WIDGET_TOPLEVEL (toplevel) || GTK_IS_PLUG (toplevel))
 973     {
 974       gtk_widget_child_focus (toplevel,direction);
 975       return;
 976     }
 977
 978   container = GTK_CONTAINER (toplevel);
 979   window = GTK_WINDOW (toplevel);
 980   bin = GTK_BIN (toplevel);
 981
 982   /* This is a copy of gtk_window_focus(), modified so that we
 983    * can detect wrap-around.
 984    */
 985   old_focus_child = container->focus_child;
 986
 987   if (old_focus_child)
 988     {
 989       if (gtk_widget_child_focus (old_focus_child, direction))
 990         return;
 991
 992       /* We are allowed exactly one wrap-around per sequence of focus
 993        * events
 994        */
 995       if (_gtk_socket_windowing_embed_get_focus_wrapped ())
 996         return;
 997       else
 998         _gtk_socket_windowing_embed_set_focus_wrapped ();
 999     }
1000
1001   if (window->focus_widget)
1002     {
1003       /* Wrapped off the end, clear the focus setting for the toplevel */
1004       parent = window->focus_widget->parent;
1005       while (parent)
1006         {
1007           gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
1008           parent = GTK_WIDGET (parent)->parent;
1009         }
1010
1011       gtk_window_set_focus (GTK_WINDOW (container), NULL);
1012     }
1013
1014   /* Now try to focus the first widget in the window */
1015   if (bin->child)
1016     {
1017       if (gtk_widget_child_focus (bin->child, direction))
1018         return;
1019     }
1020 }
1021
1022 #define __GTK_SOCKET_C__
1023 #include "gtkaliasdef.c"