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
  33 #include "win32/gdkwin32.h"
  34
  35 #include "gtkwin32embed.h"
  36
  37 #if defined(_MSC_VER) && (WINVER < 0x0500)
  38 #ifndef GA_PARENT
  39 #define GA_PARENT 1
  40 #endif
  41 WINUSERAPI HWND WINAPI GetAncestor(HWND,UINT);
  42 #endif
  43
  44 GdkNativeWindow
  45 _gtk_plug_windowing_get_id (GtkPlug *plug)
  46 {
  47   return (GdkNativeWindow) GDK_WINDOW_HWND (gtk_widget_get_window (GTK_WIDGET (plug)));
  48 }
  49
  50 void
  51 _gtk_plug_windowing_realize_toplevel (GtkPlug *plug)
  52 {
  53   GtkPlugPrivate *priv = plug->priv;
  54
  55   if (priv->socket_window)
  56     {
  57       _gtk_win32_embed_send (priv->socket_window,
  58                              GTK_WIN32_EMBED_PARENT_NOTIFY,
  59                              (WPARAM) GDK_WINDOW_HWND (gtk_widget_get_window (GTK_WIDGET (plug))),
  60                              GTK_WIN32_EMBED_PROTOCOL_VERSION);
  61       _gtk_win32_embed_send (priv->socket_window,
  62                              GTK_WIN32_EMBED_EVENT_PLUG_MAPPED, 0, 0);
  63     }
  64 }
  65
  66 void
  67 _gtk_plug_windowing_map_toplevel (GtkPlug *plug)
  68 {
  69   GtkPlugPrivate *priv = plug->priv;
  70
  71   if (priv->socket_window)
  72     _gtk_win32_embed_send (priv->socket_window,
  73                            GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,
  74                            1, 0);
  75 }
  76
  77 void
  78 _gtk_plug_windowing_unmap_toplevel (GtkPlug *plug)
  79 {
  80   GtkPlugPrivate *priv = plug->priv;
  81
  82   if (priv->socket_window)
  83     _gtk_win32_embed_send (priv->socket_window,
  84                            GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,
  85                            0, 0);
  86 }
  87
  88 void
  89 _gtk_plug_windowing_set_focus (GtkPlug *plug)
  90 {
  91   GtkPlugPrivate *priv = plug->priv;
  92
  93   if (priv->socket_window)
  94     _gtk_win32_embed_send (priv->socket_window,
  95                            GTK_WIN32_EMBED_REQUEST_FOCUS,
  96                            0, 0);
  97 }
  98
  99 void
 100 _gtk_plug_windowing_add_grabbed_key (GtkPlug        *plug,
 101                                      guint           accelerator_key,
 102                                      GdkModifierType accelerator_mods)
 103 {
 104   GtkPlugPrivate *priv = plug->priv;
 105
 106   if (priv->socket_window)
 107     _gtk_win32_embed_send (priv->socket_window,
 108                            GTK_WIN32_EMBED_GRAB_KEY,
 109                            accelerator_key, accelerator_mods);
 110 }
 111
 112 void
 113 _gtk_plug_windowing_remove_grabbed_key (GtkPlug        *plug,
 114                                         guint           accelerator_key,
 115                                         GdkModifierType accelerator_mods)
 116 {
 117   GtkPlugPrivate *priv = plug->priv;
 118
 119   if (priv->socket_window)
 120     _gtk_win32_embed_send (priv->socket_window,
 121                            GTK_WIN32_EMBED_UNGRAB_KEY,
 122                            accelerator_key, accelerator_mods);
 123 }
 124
 125 void
 126 _gtk_plug_windowing_focus_to_parent (GtkPlug         *plug,
 127                                      GtkDirectionType direction)
 128 {
 129   GtkPlugPrivate *priv = plug->priv;
 130   GtkWin32EmbedMessageType message = GTK_WIN32_EMBED_FOCUS_PREV;
 131
 132   switch (direction)
 133     {
 134     case GTK_DIR_UP:
 135     case GTK_DIR_LEFT:
 136     case GTK_DIR_TAB_BACKWARD:
 137       message = GTK_WIN32_EMBED_FOCUS_PREV;
 138       break;
 139     case GTK_DIR_DOWN:
 140     case GTK_DIR_RIGHT:
 141     case GTK_DIR_TAB_FORWARD:
 142       message = GTK_WIN32_EMBED_FOCUS_NEXT;
 143       break;
 144     }
 145
 146   _gtk_win32_embed_send_focus_message (priv->socket_window, message, 0);
 147 }
 148
 149 GdkFilterReturn
 150 _gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
 151                                  GdkEvent  *event,
 152                                  gpointer   data)
 153 {
 154   GtkPlug *plug = GTK_PLUG (data);
 155   GtkPlugPrivate *priv = plug->priv;
 156   MSG *msg = (MSG *) gdk_xevent;
 157   GdkFilterReturn return_val = GDK_FILTER_CONTINUE;
 158
 159   switch (msg->message)
 160     {
 161       /* What message should we look for to notice the reparenting?
 162        * Maybe WM_WINDOWPOSCHANGED will work? This is handled in the
 163        * X11 implementation by handling ReparentNotify. Handle this
 164        * only for cross-process embedding, otherwise we get odd
 165        * crashes in testsocket.
 166        */
 167     case WM_WINDOWPOSCHANGED:
 168       if (!priv->same_app)
 169         {
 170           HWND parent = GetAncestor (msg->hwnd, GA_PARENT);
 171           gboolean was_embedded = priv->socket_window != NULL;
 172           GdkScreen *screen = gdk_drawable_get_screen (event->any.window);
 173           GdkDisplay *display = gdk_screen_get_display (screen);
 174
 175           GTK_NOTE (PLUGSOCKET, g_printerr ("WM_WINDOWPOSCHANGED: hwnd=%p GA_PARENT=%p socket_window=%p\n", msg->hwnd, parent, priv->socket_window));
 176           g_object_ref (plug);
 177           if (was_embedded)
 178             {
 179               /* End of embedding protocol for previous socket */
 180               if (parent != GDK_WINDOW_HWND (priv->socket_window))
 181                 {
 182                   GtkWidget *widget = GTK_WIDGET (plug);
 183
 184                   GTK_NOTE (PLUGSOCKET, g_printerr ("was_embedded, current parent != socket_window\n"));
 185                   gdk_window_set_user_data (priv->socket_window, NULL);
 186                   g_object_unref (priv->socket_window);
 187                   priv->socket_window = NULL;
 188
 189                   /* Emit a delete window, as if the user attempted to
 190                    * close the toplevel. Only do this if we are being
 191                    * reparented to the desktop window. Moving from one
 192                    * embedder to another should be invisible to the app.
 193                    */
 194                   if (parent == GetDesktopWindow ())
 195                     {
 196                       GTK_NOTE (PLUGSOCKET, g_printerr ("current parent is root window\n"));
 197                       _gtk_plug_send_delete_event (widget);
 198                       return_val = GDK_FILTER_REMOVE;
 199                     }
 200                 }
 201               else
 202                 {
 203                   GTK_NOTE (PLUGSOCKET, g_printerr ("still same parent\n"));
 204                   goto done;
 205                 }
 206             }
 207
 208           if (parent != GetDesktopWindow ())
 209             {
 210               /* Start of embedding protocol */
 211
 212               GTK_NOTE (PLUGSOCKET, g_printerr ("start of embedding\n"));
 213               priv->socket_window = gdk_window_lookup_for_display (display, (GdkNativeWindow) parent);
 214               if (priv->socket_window)
 215                 {
 216                   gpointer user_data = NULL;
 217
 218                   GTK_NOTE (PLUGSOCKET, g_printerr ("already had socket_window\n"));
 219                   gdk_window_get_user_data (priv->socket_window, &user_data);
 220
 221                   if (user_data)
 222                     {
 223                       g_warning (G_STRLOC "Plug reparented unexpectedly into window in the same process");
 224                       priv->socket_window = NULL;
 225                       break;
 226                     }
 227
 228                   g_object_ref (priv->socket_window);
 229                 }
 230               else
 231                 {
 232                   priv->socket_window = gdk_window_foreign_new_for_display (display, (GdkNativeWindow) parent);
 233                   if (!priv->socket_window) /* Already gone */
 234                     break;
 235                 }
 236
 237               _gtk_plug_add_all_grabbed_keys (plug);
 238
 239               if (!was_embedded)
 240                 g_signal_emit_by_name (plug, "embedded");
 241             }
 242         done:
 243           g_object_unref (plug);
 244         }
 245       break;
 246
 247     case WM_SIZE:
 248       if (!priv->same_app && priv->socket_window)
 249         {
 250           _gtk_win32_embed_send (priv->socket_window,
 251                                  GTK_WIN32_EMBED_PLUG_RESIZED,
 252                                  0, 0);
 253         }
 254       break;
 255
 256     default:
 257       if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_WINDOW_ACTIVATE))
 258         {
 259           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: WINDOW_ACTIVATE received\n"));
 260           _gtk_win32_embed_push_message (msg);
 261           _gtk_window_set_is_active (GTK_WINDOW (plug), TRUE);
 262           _gtk_win32_embed_pop_message ();
 263           return_val = GDK_FILTER_REMOVE;
 264         }
 265       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_WINDOW_DEACTIVATE))
 266         {
 267           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: WINDOW_DEACTIVATE received\n"));
 268           _gtk_win32_embed_push_message (msg);
 269           _gtk_window_set_is_active (GTK_WINDOW (plug), FALSE);
 270           _gtk_win32_embed_pop_message ();
 271           return_val = GDK_FILTER_REMOVE;
 272         }
 273       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_IN))
 274         {
 275           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: FOCUS_IN received\n"));
 276           _gtk_win32_embed_push_message (msg);
 277           _gtk_window_set_has_toplevel_focus (GTK_WINDOW (plug), TRUE);
 278           switch (msg->wParam)
 279             {
 280             case GTK_WIN32_EMBED_FOCUS_CURRENT:
 281               break;
 282             case GTK_WIN32_EMBED_FOCUS_FIRST:
 283               _gtk_plug_focus_first_last (plug, GTK_DIR_TAB_FORWARD);
 284               break;
 285             case GTK_WIN32_EMBED_FOCUS_LAST:
 286               _gtk_plug_focus_first_last (plug, GTK_DIR_TAB_BACKWARD);
 287               break;
 288             }
 289           _gtk_win32_embed_pop_message ();
 290           return_val = GDK_FILTER_REMOVE;
 291         }
 292       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_OUT))
 293         {
 294           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: FOCUS_OUT received\n"));
 295           _gtk_win32_embed_push_message (msg);
 296           _gtk_window_set_has_toplevel_focus (GTK_WINDOW (plug), FALSE);
 297           _gtk_win32_embed_pop_message ();
 298           return_val = GDK_FILTER_REMOVE;
 299         }
 300       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_MODALITY_ON))
 301         {
 302           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: MODALITY_ON received\n"));
 303           _gtk_win32_embed_push_message (msg);
 304           _gtk_plug_handle_modality_on (plug);
 305           _gtk_win32_embed_pop_message ();
 306           return_val = GDK_FILTER_REMOVE;
 307         }
 308       else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_MODALITY_OFF))
 309         {
 310           GTK_NOTE (PLUGSOCKET, g_printerr ("GtkPlug: MODALITY_OFF received\n"));
 311           _gtk_win32_embed_push_message (msg);
 312           _gtk_plug_handle_modality_off (plug);
 313           _gtk_win32_embed_pop_message ();
 314           return_val = GDK_FILTER_REMOVE;
 315         }
 316       break;
 317     }
 318
 319   return return_val;
 320 }