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_get_realized (GTK_WIDGET (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_get_realized (GTK_WIDGET (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_get_realized (GTK_WIDGET (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_realized (widget, TRUE);
 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
 376   if (GTK_IS_WINDOW (toplevel))
 377     _gtk_socket_windowing_end_embedding_toplevel (socket);
 378
 379   g_object_unref (socket->plug_window);
 380   socket->plug_window = NULL;
 381   socket->current_width = 0;
 382   socket->current_height = 0;
 383   private->resize_count = 0;
 384
 385   gtk_accel_group_disconnect (socket->accel_group, NULL);
 386 }
 387
 388 static void
 389 gtk_socket_unrealize (GtkWidget *widget)
 390 {
 391   GtkSocket *socket = GTK_SOCKET (widget);
 392
 393   gtk_widget_set_realized (widget, FALSE);
 394
 395   if (socket->plug_widget)
 396     {
 397       _gtk_plug_remove_from_socket (GTK_PLUG (socket->plug_widget), socket);
 398     }
 399   else if (socket->plug_window)
 400     {
 401       _gtk_socket_end_embedding (socket);
 402     }
 403
 404   GTK_WIDGET_CLASS (gtk_socket_parent_class)->unrealize (widget);
 405 }
 406
 407 static void
 408 gtk_socket_size_request (GtkWidget      *widget,
 409                          GtkRequisition *requisition)
 410 {
 411   GtkSocket *socket = GTK_SOCKET (widget);
 412
 413   if (socket->plug_widget)
 414     {
 415       gtk_widget_size_request (socket->plug_widget, requisition);
 416     }
 417   else
 418     {
 419       if (socket->is_mapped && !socket->have_size && socket->plug_window)
 420         _gtk_socket_windowing_size_request (socket);
 421
 422       if (socket->is_mapped && socket->have_size)
 423         {
 424           requisition->width = MAX (socket->request_width, 1);
 425           requisition->height = MAX (socket->request_height, 1);
 426         }
 427       else
 428         {
 429           requisition->width = 1;
 430           requisition->height = 1;
 431         }
 432     }
 433 }
 434
 435 static void
 436 gtk_socket_size_allocate (GtkWidget     *widget,
 437                           GtkAllocation *allocation)
 438 {
 439   GtkSocket *socket = GTK_SOCKET (widget);
 440
 441   widget->allocation = *allocation;
 442   if (gtk_widget_get_realized (widget))
 443     {
 444       gdk_window_move_resize (widget->window,
 445                               allocation->x, allocation->y,
 446                               allocation->width, allocation->height);
 447
 448       if (socket->plug_widget)
 449         {
 450           GtkAllocation child_allocation;
 451
 452           child_allocation.x = 0;
 453           child_allocation.y = 0;
 454           child_allocation.width = allocation->width;
 455           child_allocation.height = allocation->height;
 456
 457           gtk_widget_size_allocate (socket->plug_widget, &child_allocation);
 458         }
 459       else if (socket->plug_window)
 460         {
 461           GtkSocketPrivate *private = _gtk_socket_get_private (socket);
 462
 463           gdk_error_trap_push ();
 464
 465           if (allocation->width != socket->current_width ||
 466               allocation->height != socket->current_height)
 467             {
 468               gdk_window_move_resize (socket->plug_window,
 469                                       0, 0,
 470                                       allocation->width, allocation->height);
 471               if (private->resize_count)
 472                 private->resize_count--;
 473
 474               GTK_NOTE (PLUGSOCKET,
 475                         g_message ("GtkSocket - allocated: %d %d",
 476                                    allocation->width, allocation->height));
 477               socket->current_width = allocation->width;
 478               socket->current_height = allocation->height;
 479             }
 480
 481           if (socket->need_map)
 482             {
 483               gdk_window_show (socket->plug_window);
 484               socket->need_map = FALSE;
 485             }
 486
 487           while (private->resize_count)
 488             {
 489               _gtk_socket_windowing_send_configure_event (socket);
 490               private->resize_count--;
 491               GTK_NOTE (PLUGSOCKET,
 492                         g_message ("GtkSocket - sending synthetic configure: %d %d",
 493                                    allocation->width, allocation->height));
 494             }
 495
 496           gdk_display_sync (gtk_widget_get_display (widget));
 497           gdk_error_trap_pop ();
 498         }
 499     }
 500 }
 501
 502 static gboolean
 503 activate_key (GtkAccelGroup  *accel_group,
 504               GObject        *acceleratable,
 505               guint           accel_key,
 506               GdkModifierType accel_mods,
 507               GrabbedKey     *grabbed_key)
 508 {
 509   GdkEvent *gdk_event = gtk_get_current_event ();
 510
 511   GtkSocket *socket = g_object_get_data (G_OBJECT (accel_group), "gtk-socket");
 512   gboolean retval = FALSE;
 513
 514   if (gdk_event && gdk_event->type == GDK_KEY_PRESS && socket->plug_window)
 515     {
 516       _gtk_socket_windowing_send_key_event (socket, gdk_event, TRUE);
 517       retval = TRUE;
 518     }
 519
 520   if (gdk_event)
 521     gdk_event_free (gdk_event);
 522
 523   return retval;
 524 }
 525
 526 static gboolean
 527 find_accel_key (GtkAccelKey *key,
 528                 GClosure    *closure,
 529                 gpointer     data)
 530 {
 531   GrabbedKey *grabbed_key = data;
 532
 533   return (key->accel_key == grabbed_key->accel_key &&
 534           key->accel_mods == grabbed_key->accel_mods);
 535 }
 536
 537 /**
 538  * _gtk_socket_add_grabbed_key:
 539  *
 540  * @socket: a #GtkSocket
 541  * @keyval: a key
 542  * @modifiers: modifiers for the key
 543  *
 544  * Called from the GtkSocket platform-specific backend when the
 545  * corresponding plug has told the socket to grab a key.
 546  */
 547 void
 548 _gtk_socket_add_grabbed_key (GtkSocket       *socket,
 549                              guint            keyval,
 550                              GdkModifierType  modifiers)
 551 {
 552   GClosure *closure;
 553   GrabbedKey *grabbed_key;
 554
 555   grabbed_key = g_new (GrabbedKey, 1);
 556
 557   grabbed_key->accel_key = keyval;
 558   grabbed_key->accel_mods = modifiers;
 559
 560   if (gtk_accel_group_find (socket->accel_group,
 561                             find_accel_key,
 562                             &grabbed_key))
 563     {
 564       g_warning ("GtkSocket: request to add already present grabbed key %u,%#x\n",
 565                  keyval, modifiers);
 566       g_free (grabbed_key);
 567       return;
 568     }
 569
 570   closure = g_cclosure_new (G_CALLBACK (activate_key), grabbed_key, (GClosureNotify)g_free);
 571
 572   gtk_accel_group_connect (socket->accel_group, keyval, modifiers, GTK_ACCEL_LOCKED,
 573                            closure);
 574 }
 575
 576 /**
 577  * _gtk_socket_remove_grabbed_key:
 578  *
 579  * @socket: a #GtkSocket
 580  * @keyval: a key
 581  * @modifiers: modifiers for the key
 582  *
 583  * Called from the GtkSocket backend when the corresponding plug has
 584  * told the socket to remove a key grab.
 585  */
 586 void
 587 _gtk_socket_remove_grabbed_key (GtkSocket      *socket,
 588                                 guint           keyval,
 589                                 GdkModifierType modifiers)
 590 {
 591   if (!gtk_accel_group_disconnect_key (socket->accel_group, keyval, modifiers))
 592     g_warning ("GtkSocket: request to remove non-present grabbed key %u,%#x\n",
 593                keyval, modifiers);
 594 }
 595
 596 static void
 597 socket_update_focus_in (GtkSocket *socket)
 598 {
 599   gboolean focus_in = FALSE;
 600
 601   if (socket->plug_window)
 602     {
 603       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 604
 605       if (gtk_widget_is_toplevel (toplevel) &&
 606           GTK_WINDOW (toplevel)->has_toplevel_focus &&
 607           gtk_widget_is_focus (GTK_WIDGET (socket)))
 608         focus_in = TRUE;
 609     }
 610
 611   if (focus_in != socket->focus_in)
 612     {
 613       socket->focus_in = focus_in;
 614
 615       _gtk_socket_windowing_focus_change (socket, focus_in);
 616     }
 617 }
 618
 619 static void
 620 socket_update_active (GtkSocket *socket)
 621 {
 622   gboolean active = FALSE;
 623
 624   if (socket->plug_window)
 625     {
 626       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 627
 628       if (gtk_widget_is_toplevel (toplevel) &&
 629           GTK_WINDOW (toplevel)->is_active)
 630         active = TRUE;
 631     }
 632
 633   if (active != socket->active)
 634     {
 635       socket->active = active;
 636
 637       _gtk_socket_windowing_update_active (socket, active);
 638     }
 639 }
 640
 641 static void
 642 gtk_socket_hierarchy_changed (GtkWidget *widget,
 643                               GtkWidget *old_toplevel)
 644 {
 645   GtkSocket *socket = GTK_SOCKET (widget);
 646   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
 647
 648   if (toplevel && !GTK_IS_WINDOW (toplevel))
 649     toplevel = NULL;
 650
 651   if (toplevel != socket->toplevel)
 652     {
 653       if (socket->toplevel)
 654         {
 655           gtk_window_remove_accel_group (GTK_WINDOW (socket->toplevel), socket->accel_group);
 656           g_signal_handlers_disconnect_by_func (socket->toplevel,
 657                                                 socket_update_focus_in,
 658                                                 socket);
 659           g_signal_handlers_disconnect_by_func (socket->toplevel,
 660                                                 socket_update_active,
 661                                                 socket);
 662         }
 663
 664       socket->toplevel = toplevel;
 665
 666       if (toplevel)
 667         {
 668           gtk_window_add_accel_group (GTK_WINDOW (socket->toplevel), socket->accel_group);
 669           g_signal_connect_swapped (socket->toplevel, "notify::has-toplevel-focus",
 670                                     G_CALLBACK (socket_update_focus_in), socket);
 671           g_signal_connect_swapped (socket->toplevel, "notify::is-active",
 672                                     G_CALLBACK (socket_update_active), socket);
 673         }
 674
 675       socket_update_focus_in (socket);
 676       socket_update_active (socket);
 677     }
 678 }
 679
 680 static void
 681 gtk_socket_grab_notify (GtkWidget *widget,
 682                         gboolean   was_grabbed)
 683 {
 684   GtkSocket *socket = GTK_SOCKET (widget);
 685
 686   if (!socket->same_app)
 687     _gtk_socket_windowing_update_modality (socket, !was_grabbed);
 688 }
 689
 690 static gboolean
 691 gtk_socket_key_event (GtkWidget   *widget,
 692                       GdkEventKey *event)
 693 {
 694   GtkSocket *socket = GTK_SOCKET (widget);
 695
 696   if (gtk_widget_has_focus (widget) && socket->plug_window && !socket->plug_widget)
 697     {
 698       _gtk_socket_windowing_send_key_event (socket, (GdkEvent *) event, FALSE);
 699
 700       return TRUE;
 701     }
 702   else
 703     return FALSE;
 704 }
 705
 706 static void
 707 gtk_socket_notify (GObject    *object,
 708                    GParamSpec *pspec)
 709 {
 710   if (!strcmp (pspec->name, "is-focus"))
 711     return;
 712   socket_update_focus_in (GTK_SOCKET (object));
 713 }
 714
 715 /**
 716  * _gtk_socket_claim_focus:
 717  *
 718  * @socket: a #GtkSocket
 719  * @send_event: huh?
 720  *
 721  * Claims focus for the socket. XXX send_event?
 722  */
 723 void
 724 _gtk_socket_claim_focus (GtkSocket *socket,
 725                          gboolean   send_event)
 726 {
 727   GtkWidget *widget = GTK_WIDGET (socket);
 728
 729   if (!send_event)
 730     socket->focus_in = TRUE;    /* Otherwise, our notify handler will send FOCUS_IN  */
 731
 732   /* Oh, the trickery... */
 733
 734   gtk_widget_set_can_focus (widget, TRUE);
 735   gtk_widget_grab_focus (widget);
 736   gtk_widget_set_can_focus (widget, FALSE);
 737 }
 738
 739 static gboolean
 740 gtk_socket_focus (GtkWidget       *widget,
 741                   GtkDirectionType direction)
 742 {
 743   GtkSocket *socket = GTK_SOCKET (widget);
 744
 745   if (socket->plug_widget)
 746     return gtk_widget_child_focus (socket->plug_widget, direction);
 747
 748   if (!gtk_widget_is_focus (widget))
 749     {
 750       _gtk_socket_windowing_focus (socket, direction);
 751       _gtk_socket_claim_focus (socket, FALSE);
 752
 753       return TRUE;
 754     }
 755   else
 756     return FALSE;
 757 }
 758
 759 static void
 760 gtk_socket_remove (GtkContainer *container,
 761                    GtkWidget    *child)
 762 {
 763   GtkSocket *socket = GTK_SOCKET (container);
 764
 765   g_return_if_fail (child == socket->plug_widget);
 766
 767   _gtk_plug_remove_from_socket (GTK_PLUG (socket->plug_widget), socket);
 768 }
 769
 770 static void
 771 gtk_socket_forall (GtkContainer *container,
 772                    gboolean      include_internals,
 773                    GtkCallback   callback,
 774                    gpointer      callback_data)
 775 {
 776   GtkSocket *socket = GTK_SOCKET (container);
 777
 778   if (socket->plug_widget)
 779     (* callback) (socket->plug_widget, callback_data);
 780 }
 781
 782 /**
 783  * _gtk_socket_add_window:
 784  *
 785  * @socket: a #GtkSocket
 786  * @xid: the native identifier for a window
 787  * @need_reparent: whether the socket's plug's window needs to be
 788  *                 reparented to the socket
 789  *
 790  * Adds a window to a GtkSocket.
 791  */
 792 void
 793 _gtk_socket_add_window (GtkSocket       *socket,
 794                         GdkNativeWindow  xid,
 795                         gboolean         need_reparent)
 796 {
 797   GtkWidget *widget = GTK_WIDGET (socket);
 798   GdkDisplay *display = gtk_widget_get_display (widget);
 799   gpointer user_data = NULL;
 800
 801   socket->plug_window = gdk_window_lookup_for_display (display, xid);
 802
 803   if (socket->plug_window)
 804     {
 805       g_object_ref (socket->plug_window);
 806       gdk_window_get_user_data (socket->plug_window, &user_data);
 807     }
 808
 809   if (user_data)                /* A widget's window in this process */
 810     {
 811       GtkWidget *child_widget = user_data;
 812
 813       if (!GTK_IS_PLUG (child_widget))
 814         {
 815           g_warning (G_STRLOC ": Can't add non-GtkPlug to GtkSocket");
 816           socket->plug_window = NULL;
 817           gdk_error_trap_pop ();
 818
 819           return;
 820         }
 821
 822       _gtk_plug_add_to_socket (GTK_PLUG (child_widget), socket);
 823     }
 824   else                          /* A foreign window */
 825     {
 826       GtkWidget *toplevel;
 827       GdkDragProtocol protocol;
 828
 829       gdk_error_trap_push ();
 830
 831       if (!socket->plug_window)
 832         {
 833           socket->plug_window = gdk_window_foreign_new_for_display (display, xid);
 834           if (!socket->plug_window) /* was deleted before we could get it */
 835             {
 836               gdk_error_trap_pop ();
 837               return;
 838             }
 839         }
 840
 841       _gtk_socket_windowing_select_plug_window_input (socket);
 842
 843       if (gdk_error_trap_pop ())
 844         {
 845           g_object_unref (socket->plug_window);
 846           socket->plug_window = NULL;
 847           return;
 848         }
 849
 850       /* OK, we now will reliably get destroy notification on socket->plug_window */
 851
 852       gdk_error_trap_push ();
 853
 854       if (need_reparent)
 855         {
 856           gdk_window_hide (socket->plug_window); /* Shouldn't actually be necessary for XEMBED, but just in case */
 857           gdk_window_reparent (socket->plug_window, widget->window, 0, 0);
 858         }
 859
 860       socket->have_size = FALSE;
 861
 862       _gtk_socket_windowing_embed_get_info (socket);
 863
 864       socket->need_map = socket->is_mapped;
 865
 866       if (gdk_drag_get_protocol_for_display (display, xid, &protocol))
 867         gtk_drag_dest_set_proxy (GTK_WIDGET (socket), socket->plug_window,
 868                                  protocol, TRUE);
 869
 870       gdk_display_sync (display);
 871       gdk_error_trap_pop ();
 872
 873       gdk_window_add_filter (socket->plug_window,
 874                              _gtk_socket_windowing_filter_func,
 875                              socket);
 876
 877       /* Add a pointer to the socket on our toplevel window */
 878
 879       toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 880       if (GTK_IS_WINDOW (toplevel))
 881         gtk_window_add_embedded_xid (GTK_WINDOW (toplevel), xid);
 882
 883       _gtk_socket_windowing_embed_notify (socket);
 884
 885       socket_update_active (socket);
 886       socket_update_focus_in (socket);
 887
 888       gtk_widget_queue_resize (GTK_WIDGET (socket));
 889     }
 890
 891   if (socket->plug_window)
 892     g_signal_emit (socket, socket_signals[PLUG_ADDED], 0);
 893 }
 894
 895 /**
 896  * _gtk_socket_handle_map_request:
 897  *
 898  * @socket: a #GtkSocket
 899  *
 900  * Called from the GtkSocket backend when the plug has been mapped.
 901  */
 902 void
 903 _gtk_socket_handle_map_request (GtkSocket *socket)
 904 {
 905   if (!socket->is_mapped)
 906     {
 907       socket->is_mapped = TRUE;
 908       socket->need_map = TRUE;
 909
 910       gtk_widget_queue_resize (GTK_WIDGET (socket));
 911     }
 912 }
 913
 914 /**
 915  * _gtk_socket_unmap_notify:
 916  *
 917  * @socket: a #GtkSocket
 918  *
 919  * Called from the GtkSocket backend when the plug has been unmapped ???
 920  */
 921 void
 922 _gtk_socket_unmap_notify (GtkSocket *socket)
 923 {
 924   if (socket->is_mapped)
 925     {
 926       socket->is_mapped = FALSE;
 927       gtk_widget_queue_resize (GTK_WIDGET (socket));
 928     }
 929 }
 930
 931 /**
 932  * _gtk_socket_advance_toplevel_focus:
 933  *
 934  * @socket: a #GtkSocket
 935  * @direction: a direction
 936  *
 937  * Called from the GtkSocket backend when the corresponding plug
 938  * has told the socket to move the focus.
 939  */
 940 void
 941 _gtk_socket_advance_toplevel_focus (GtkSocket        *socket,
 942                                     GtkDirectionType  direction)
 943 {
 944   GtkBin *bin;
 945   GtkWindow *window;
 946   GtkContainer *container;
 947   GtkWidget *toplevel;
 948   GtkWidget *old_focus_child;
 949   GtkWidget *parent;
 950
 951   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
 952   if (!toplevel)
 953     return;
 954
 955   if (!gtk_widget_is_toplevel (toplevel) || GTK_IS_PLUG (toplevel))
 956     {
 957       gtk_widget_child_focus (toplevel,direction);
 958       return;
 959     }
 960
 961   container = GTK_CONTAINER (toplevel);
 962   window = GTK_WINDOW (toplevel);
 963   bin = GTK_BIN (toplevel);
 964
 965   /* This is a copy of gtk_window_focus(), modified so that we
 966    * can detect wrap-around.
 967    */
 968   old_focus_child = container->focus_child;
 969
 970   if (old_focus_child)
 971     {
 972       if (gtk_widget_child_focus (old_focus_child, direction))
 973         return;
 974
 975       /* We are allowed exactly one wrap-around per sequence of focus
 976        * events
 977        */
 978       if (_gtk_socket_windowing_embed_get_focus_wrapped ())
 979         return;
 980       else
 981         _gtk_socket_windowing_embed_set_focus_wrapped ();
 982     }
 983
 984   if (window->focus_widget)
 985     {
 986       /* Wrapped off the end, clear the focus setting for the toplevel */
 987       parent = window->focus_widget->parent;
 988       while (parent)
 989         {
 990           gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
 991           parent = GTK_WIDGET (parent)->parent;
 992         }
 993
 994       gtk_window_set_focus (GTK_WINDOW (container), NULL);
 995     }
 996
 997   /* Now try to focus the first widget in the window */
 998   if (bin->child)
 999     {
1000       if (gtk_widget_child_focus (bin->child, direction))
1001         return;
1002     }
1003 }
1004
1005 #define __GTK_SOCKET_C__
1006 #include "gtkaliasdef.c"