Pileus Git - ~andy/gtk/blob - gtk/gtkplug-win32.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * Copyright (C) 2005 Novell, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 /* By Tor Lillqvist <tml@novell.com> 2005 */
  21
  22 /*
  23  * Modified by the GTK+ Team and others 1997-2005.  See the AUTHORS
  24  * file for a list of people on the GTK+ Team.  See the ChangeLog
  25  * files for a list of changes.  These files are distributed with
  26  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  27  */
  28
  29 #include "gtkmarshalers.h"
  30 #include "gtkplug.h"
  31 #include "gtkplugprivate.h"
  32 #include "gtkdebug.h"
  33
  34 #include "win32/gdkwin32.h"
  35
  36 #include "gtkwin32embed.h"
  37
  38 #if defined(_MSC_VER) && (WINVER < 0x0500)
  39 #ifndef GA_PARENT
  40 #define GA_PARENT 1
  41 #endif
  42 WINUSERAPI HWND WINAPI GetAncestor(HWND,UINT);
  43 #endif
  44
  45 GdkNativeWindow
  46 _gtk_plug_windowing_get_id (GtkPlug *plug)
  47 {
  48   return (GdkNativeWindow) GDK_WINDOW_HWND (gtk_widget_get_window (GTK_WIDGET (plug)));
  49 }
  50
  51 void
  52 _gtk_plug_windowing_realize_toplevel (GtkPlug *plug)
  53 {
  54   GtkPlugPrivate *priv = plug->priv;
  55
  56   if (priv->socket_window)
  57     {
  58       _gtk_win32_embed_send (priv->socket_window,
  59                              GTK_WIN32_EMBED_PARENT_NOTIFY,
  60                              (WPARAM) GDK_WINDOW_HWND (gtk_widget_get_window (GTK_WIDGET (plug))),
  61                              GTK_WIN32_EMBED_PROTOCOL_VERSION);
  62       _gtk_win32_embed_send (priv->socket_window,
  63                              GTK_WIN32_EMBED_EVENT_PLUG_MAPPED, 0, 0);
  64     }
  65 }
  66
  67 void
  68 _gtk_plug_windowing_map_toplevel (GtkPlug *plug)
  69 {
  70   GtkPlugPrivate *priv = plug->priv;
  71
  72   if (priv->socket_window)
  73     _gtk_win32_embed_send (priv->socket_window,
  74                            GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,
  75                            1, 0);
  76 }
  77
  78 void
  79 _gtk_plug_windowing_unmap_toplevel (GtkPlug *plug)
  80 {
  81   GtkPlugPrivate *priv = plug->priv;
  82
  83   if (priv->socket_window)
  84     _gtk_win32_embed_send (priv->socket_window,
  85                            GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,
  86                            0, 0);
  87 }
  88
  89 void
  90 _gtk_plug_windowing_set_focus (GtkPlug *plug)
  91 {
  92   GtkPlugPrivate *priv = plug->priv;
  93
  94   if (priv->socket_window)
  95     _gtk_win32_embed_send (priv->socket_window,
  96                            GTK_WIN32_EMBED_REQUEST_FOCUS,
  97                            0, 0);
  98 }
  99
 100 void
 101 _gtk_plug_windowing_add_grabbed_key (GtkPlug        *plug,
 102                                      guint           accelerator_key,
 103                                      GdkModifierType accelerator_mods)
 104 {
 105   GtkPlugPrivate *priv = plug->priv;
 106
 107   if (priv->socket_window)
 108     _gtk_win32_embed_send (priv->socket_window,
 109                            GTK_WIN32_EMBED_GRAB_KEY,
 110                            accelerator_key, accelerator_mods);
 111 }
 112
 113 void
 114 _gtk_plug_windowing_remove_grabbed_key (GtkPlug        *plug,
 115                                         guint           accelerator_key,
 116                                         GdkModifierType accelerator_mods)
 117 {
 118   GtkPlugPrivate *priv = plug->priv;
 119
 120   if (priv->socket_window)
 121     _gtk_win32_embed_send (priv->socket_window,
 122                            GTK_WIN32_EMBED_UNGRAB_KEY,
 123                            accelerator_key, accelerator_mods);
 124 }
 125
 126 void
 127 _gtk_plug_windowing_focus_to_parent (GtkPlug         *plug,
 128                                      GtkDirectionType direction)
 129 {
 130   GtkPlugPrivate *priv = plug->priv;
 131   GtkWin32EmbedMessageType message = GTK_WIN32_EMBED_FOCUS_PREV;
 132
 133   switch (direction)
 134     {
 135     case GTK_DIR_UP:
 136     case GTK_DIR_LEFT:
 137     case GTK_DIR_TAB_BACKWARD:
 138       message = GTK_WIN32_EMBED_FOCUS_PREV;
 139       break;
 140     case GTK_DIR_DOWN:
 141     case GTK_DIR_RIGHT:
 142     case GTK_DIR_TAB_FORWARD:
 143       message = GTK_WIN32_EMBED_FOCUS_NEXT;
 144       break;
 145     }
 146
 147   _gtk_win32_embed_send_focus_message (priv->socket_window, message, 0);
 148 }
 149
 150 GdkFilterReturn
 151 _gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
 152                                  GdkEvent  *event,
 153                                  gpointer   data)
 154 {
 155   GtkPlug *plug = GTK_PLUG (data);
 156   GtkPlugPrivate *priv = plug->priv;
 157   MSG *msg = (MSG *) gdk_xevent;
 158   GdkFilterReturn return_val = GDK_FILTER_CONTINUE;
 159
 160   switch (msg->message)
 161     {
 162       /* What message should we look for to notice the reparenting?
 163        * Maybe WM_WINDOWPOSCHANGED will work? This is handled in the
 164        * X11 implementation by handling ReparentNotify. Handle this
 165        * only for cross-process embedding, otherwise we get odd
 166        * crashes in testsocket.
 167        */
 168     case WM_WINDOWPOSCHANGED:
 169       if (!priv->same_app)
 170         {
 171           HWND parent = GetAncestor (msg->hwnd, GA_PARENT);
 172           gboolean was_embedded = priv->socket_window != NULL;
 173           GdkScreen *screen = gdk_window_get_screen (event->any.window);
 174           GdkDisplay *display = gdk_screen_get_display (screen);
 175
 176           GTK_NOTE (PLUGSOCKET, g_printerr ("WM_WINDOWPOSCHANGED: hwnd=%p GA_PARENT=%p socket_window=%p\n", msg->hwnd, parent, priv->socket_window));
 177           g_object_ref (plug);
 178           if (was_embedded)
 179             {
 180               /* End of embedding protocol for previous socket */
 181               if (parent != GDK_WINDOW_HWND (priv->socket_window))
 182                 {
 183                   GtkWidget *widget = GTK_WIDGET (plug);
 184
 185                   GTK_NOTE (PLUGSOCKET, g_printerr ("was_embedded, current parent != socket_window\n"));
 186                   gdk_window_set_user_data (priv->socket_window, NULL);
 187                   g_object_unref (priv->socket_window);
 188                   priv->socket_window = NULL;
 189
 190                   /* Emit a delete window, as if the user attempted to
 191                    * close the toplevel. Only do this if we are being
 192                    * reparented to the desktop window. Moving from one
 193                    * embedder to another should be invisible to the app.
 194                    */
 195                   if (parent == GetDesktopWindow ())
 196                     {
 197                       GTK_NOTE (PLUGSOCKET, g_printerr ("current parent is root window\n"));
 198                       _gtk_plug_send_delete_event (widget);
 199                       return_val = GDK_FILTER_REMOVE;
 200                     }
 201                 }
 202               else
 203                 {
 204                   GTK_NOTE (PLUGSOCKET, g_printerr ("still same parent\n"));
 205                   goto done;
 206                 }
 207             }
 208
 209           if (parent != GetDesktopWindow ())
 210             {
 211               /* Start of embedding protocol */
 212
 213               GTK_NOTE (PLUGSOCKET, g_printerr ("start of embedding\n"));
 214               priv->socket_window = gdk_window_lookup_for_display (display, (GdkNativeWindow) parent);
 215               if (priv->socket_window)
 216                 {
 217                   gpointer user_data = NULL;
 218
 219                   GTK_NOTE (PLUGSOCKET, g_printerr ("already had socket_window\n"));
 220                   gdk_window_get_user_data (priv->socket_window, &user_data);
 221
 222                   if (user_data)
 223                     {
 224                       g_warning (G_STRLOC "Plug reparented unexpectedly into window in the same process");
 225                       priv->socket_window = NULL;
 226                       break;
 227                     }
 228
 229                   g_object_ref (priv->socket_window);
 230                 }
 231               else
 232                 {
 233                   priv->socket_window = gdk_window_foreign_new_for_display (display, (GdkNativeWindow) parent);
 234                   if (!priv->socket_window) /* Already gone */
 235                     break;
 236                 }
 237
 238               _gtk_plug_add_all_grabbed_keys (plug);
 239
 240               if (!was_embedded)
 241                 g_signal_emit_by_name (plug, "embedded");
 242             }
 243         done:
 244           g_object_unref (plug);
 245         }
 246       break;
 247
 248     case WM_SIZE:
 249       if (!priv->same_app && priv->socket_window)
 250         {
 251           _gtk_win32_embed_send (priv->socket_window,
 252                                  GTK_WIN32_EMBED_PLUG_RESIZED,
 253                                  0, 0);
 254         }
 255       break;
 256
 257     default:
 258       if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_WINDOW_ACTIVATE))
 259         {
 260           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: WINDOW_ACTIVATE received\n"));
 261           _gtk_win32_embed_push_message (msg);
 262           _gtk_window_set_is_active (GTK_WINDOW (plug), TRUE);
 263           _gtk_win32_embed_pop_message ();
 264           return_val = GDK_FILTER_REMOVE;
 265         }
 266       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_WINDOW_DEACTIVATE))
 267         {
 268           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: WINDOW_DEACTIVATE received\n"));
 269           _gtk_win32_embed_push_message (msg);
 270           _gtk_window_set_is_active (GTK_WINDOW (plug), FALSE);
 271           _gtk_win32_embed_pop_message ();
 272           return_val = GDK_FILTER_REMOVE;
 273         }
 274       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_IN))
 275         {
 276           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: FOCUS_IN received\n"));
 277           _gtk_win32_embed_push_message (msg);
 278           _gtk_window_set_has_toplevel_focus (GTK_WINDOW (plug), TRUE);
 279           switch (msg->wParam)
 280             {
 281             case GTK_WIN32_EMBED_FOCUS_CURRENT:
 282               break;
 283             case GTK_WIN32_EMBED_FOCUS_FIRST:
 284               _gtk_plug_focus_first_last (plug, GTK_DIR_TAB_FORWARD);
 285               break;
 286             case GTK_WIN32_EMBED_FOCUS_LAST:
 287               _gtk_plug_focus_first_last (plug, GTK_DIR_TAB_BACKWARD);
 288               break;
 289             }
 290           _gtk_win32_embed_pop_message ();
 291           return_val = GDK_FILTER_REMOVE;
 292         }
 293       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_OUT))
 294         {
 295           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: FOCUS_OUT received\n"));
 296           _gtk_win32_embed_push_message (msg);
 297           _gtk_window_set_has_toplevel_focus (GTK_WINDOW (plug), FALSE);
 298           _gtk_win32_embed_pop_message ();
 299           return_val = GDK_FILTER_REMOVE;
 300         }
 301       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_MODALITY_ON))
 302         {
 303           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: MODALITY_ON received\n"));
 304           _gtk_win32_embed_push_message (msg);
 305           _gtk_plug_handle_modality_on (plug);
 306           _gtk_win32_embed_pop_message ();
 307           return_val = GDK_FILTER_REMOVE;
 308         }
 309       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_MODALITY_OFF))
 310         {
 311           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: MODALITY_OFF received\n"));
 312           _gtk_win32_embed_push_message (msg);
 313           _gtk_plug_handle_modality_off (plug);
 314           _gtk_win32_embed_pop_message ();
 315           return_val = GDK_FILTER_REMOVE;
 316         }
 317       break;
 318     }
 319
 320   return return_val;
 321 }