← Back to branch summary

~canonical-dx-team/ubuntu/maverick/gtk+2.0/menuproxy

« back to all changes in this revision

Viewing changes to gtk/gtksocket-win32.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-05-04 12:24:25 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20070504122425-0m8midgzrp40y8w2
Tags: 2.10.12-1ubuntu1
* Sync with Debian
* New upstream version:
  Fixed bugs:
  - 379414 file chooser warnings when changing path in the entry
  - 418585 GtkFileChooserDefault sizing code is not DPI independent
  - 419568 Crash in search if start with special letter
  - 435062 build dies with icon cache validation
  - 379399 Segfault to call gtk_print_operation_run twice.
  - 387889 cups backend has problems when there are too many printers
  - 418531 invalid read to gtkicontheme.c gtk_icon_theme_lookup_icon...
  - 423916 crash in color scheme code
  - 424042 Segmentation fault while quickly pressing Alt+arrows
  - 415260 Protect against negative indices when setting values in G...
  - 419171 XGetVisualInfo() may not set nxvisuals
  - 128852 Gdk cursors don't look good on win32
  - 344657 Ctrl-H doesn't toggle "Show Hidden Files" setting
  - 345345 PrintOperation::paginate is not emitted for class handler
  - 347567 GtkPrintOperation::end-print is not emitted if it's cance...
  - 369112 gtk_ui_manager_add_ui should accept unnamed separator
  - 392015 Selected menu item invisible on Windows Vista
  - 399253 MS-Windows Theme Bottom Tab placement rendering glitches
  - 399425 gtk_input_dialog_fill_axes() adds child to gtkscrolledwin...
  - 403251 [patch] little memory leak in GtkPrintJob
  - 403267 [patch] memory leak in GtkPageSetupUnixDialog
  - 403470 MS-Windows Theme tab placement other than on top leaks a ...
  - 404506 Windows system fonts that have multi-byte font names cann...
  - 405089 Incorrect window placement for GtkEventBox private window
  - 405515 Minor leak in gtkfilesystemmodel.c
  - 405539 gdk_pixbuf_save() for PNG saver can return FALSE without ...
  - 415681 gdk_window_clear_area includes an extra line and column o...
  - 418219 GtkRecentChooser should apply filter before sorting and c...
  - 418403 Scroll to printer after selecting it from settings
  - 421985 _gtk_print_operation_platform_backend_launch_preview
  - 421990 gtk_print_job_get_surface
  - 421993 gtk_print_operation_init
  - 423064 Conditional jump or move depends on uninitialised value(s...
  - 423722 Fix printing header in gtk-demo
  - 424168 gtk_print_operation_run on async preview
  - 425655 Don't install gtk+-unix-print-2.0.pc on non-UNIX platforms
  - 425786 GDK segfaults if XineramaQueryScreens fails
  - 428665 Lpr Backend gets stuck in infinite loop during gtk_enumer...
  - 429902 GtkPrintOperation leaks cairo contextes
  - 431997 First delay of GdkPixbufAnimationIter is wrong
  - 433242 Inconsistent scroll arrow position calculations
  - 433972 Placing gtk.Expander inside a gtk.TextView() changes gtk....
  - 434261 _gtk_toolbar_elide_underscores incorrectly handles some s...
  - 383354 ctrl-L should make 'Location' entry disappear
  - 418673 gtk_recent_manager_add_item
  - 429732 gtk_accel_group_finalize accesses invalid memory
  - 435028 WM_CLIENT_LEADER is wrong on the leader_window
  - 431067 Background of the header window is not updated
  - 338843 add recent files support inside the ui manager
  - 148535 add drop shadow to menus, tooltips, etc. under Windows XP
* debian/control.in:
  - Conflicts on ubuntulooks (<= 0.9.11-1)
* debian/patches/15_default-fallback-icon-theme.patch:
  - patch from Debian, fallback on gnome icon theme

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk/gtksocket-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 <config.h>
 
30
#include <string.h>
 
31
 
 
32
#include "gtkwindow.h"
 
33
#include "gtkplug.h"
 
34
#include "gtkprivate.h"
 
35
#include "gtksocket.h"
 
36
#include "gtksocketprivate.h"
 
37
 
 
38
#include "win32/gdkwin32.h"
 
39
 
 
40
#include "gtkwin32embed.h"
 
41
#include "gtkalias.h"
 
42
 
 
43
GdkNativeWindow
 
44
_gtk_socket_windowing_get_id (GtkSocket *socket)
 
45
{
 
46
  g_return_val_if_fail (GTK_IS_SOCKET (socket), 0);
 
47
  g_return_val_if_fail (GTK_WIDGET_ANCHORED (socket), 0);
 
48
 
 
49
  if (!GTK_WIDGET_REALIZED (socket))
 
50
    gtk_widget_realize (GTK_WIDGET (socket));
 
51
 
 
52
  return (GdkNativeWindow) GDK_WINDOW_HWND (GTK_WIDGET (socket)->window);
 
53
}
 
54
 
 
55
void
 
56
_gtk_socket_windowing_realize_window (GtkSocket *socket)
 
57
{
 
58
  /* XXX Anything needed? */
 
59
}
 
60
 
 
61
void
 
62
_gtk_socket_windowing_end_embedding_toplevel (GtkSocket *socket)
 
63
{
 
64
  gtk_window_remove_embedded_xid (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (socket))),
 
65
                                  (guint) GDK_WINDOW_HWND (socket->plug_window));
 
66
}
 
67
 
 
68
void
 
69
_gtk_socket_windowing_size_request (GtkSocket *socket)
 
70
{
 
71
  MINMAXINFO mmi;
 
72
 
 
73
  socket->request_width = 1;
 
74
  socket->request_height = 1;
 
75
  
 
76
  mmi.ptMaxSize.x = mmi.ptMaxSize.y = 16000; /* ??? */
 
77
  mmi.ptMinTrackSize.x = mmi.ptMinTrackSize.y = 1;
 
78
  mmi.ptMaxTrackSize.x = mmi.ptMaxTrackSize.y = 16000; /* ??? */
 
79
  mmi.ptMaxPosition.x = mmi.ptMaxPosition.y = 0;
 
80
 
 
81
  if (SendMessage (GDK_WINDOW_HWND (socket->plug_window), WM_GETMINMAXINFO,
 
82
                   0, (LPARAM) &mmi) == 0)
 
83
    {
 
84
      socket->request_width = mmi.ptMinTrackSize.x;
 
85
      socket->request_height = mmi.ptMinTrackSize.y;
 
86
    }
 
87
  socket->have_size = TRUE;
 
88
}
 
89
 
 
90
void
 
91
_gtk_socket_windowing_send_key_event (GtkSocket *socket,
 
92
                                      GdkEvent  *gdk_event,
 
93
                                      gboolean   mask_key_presses)
 
94
{
 
95
  PostMessage (GDK_WINDOW_HWND (socket->plug_window),
 
96
               (gdk_event->type == GDK_KEY_PRESS ? WM_KEYDOWN : WM_KEYUP),
 
97
               gdk_event->key.hardware_keycode, 0);
 
98
}
 
99
 
 
100
void
 
101
_gtk_socket_windowing_focus_change (GtkSocket *socket,
 
102
                                    gboolean   focus_in)
 
103
{
 
104
  if (focus_in)
 
105
    _gtk_win32_embed_send_focus_message (socket->plug_window,
 
106
                                         GTK_WIN32_EMBED_FOCUS_IN,
 
107
                                         GTK_WIN32_EMBED_FOCUS_CURRENT);
 
108
  else
 
109
    _gtk_win32_embed_send (socket->plug_window,
 
110
                           GTK_WIN32_EMBED_FOCUS_OUT,
 
111
                           0, 0);
 
112
}
 
113
 
 
114
void
 
115
_gtk_socket_windowing_update_active (GtkSocket *socket,
 
116
                                     gboolean   active)
 
117
{
 
118
  _gtk_win32_embed_send (socket->plug_window,
 
119
                         (active ? GTK_WIN32_EMBED_WINDOW_ACTIVATE : GTK_WIN32_EMBED_WINDOW_DEACTIVATE),
 
120
                         0, 0);
 
121
}
 
122
 
 
123
void
 
124
_gtk_socket_windowing_update_modality (GtkSocket *socket,
 
125
                                       gboolean   modality)
 
126
{
 
127
  _gtk_win32_embed_send (socket->plug_window,
 
128
                         (modality ? GTK_WIN32_EMBED_MODALITY_ON : GTK_WIN32_EMBED_MODALITY_OFF),
 
129
                         0, 0);
 
130
}
 
131
 
 
132
void
 
133
_gtk_socket_windowing_focus (GtkSocket       *socket,
 
134
                             GtkDirectionType direction)
 
135
{
 
136
  int detail = -1;
 
137
 
 
138
  switch (direction)
 
139
    {
 
140
    case GTK_DIR_UP:
 
141
    case GTK_DIR_LEFT:
 
142
    case GTK_DIR_TAB_BACKWARD:
 
143
      detail = GTK_WIN32_EMBED_FOCUS_LAST;
 
144
      break;
 
145
    case GTK_DIR_DOWN:
 
146
    case GTK_DIR_RIGHT:
 
147
    case GTK_DIR_TAB_FORWARD:
 
148
      detail = GTK_WIN32_EMBED_FOCUS_FIRST;
 
149
      break;
 
150
    }
 
151
  
 
152
  _gtk_win32_embed_send_focus_message (socket->plug_window,
 
153
                                       GTK_WIN32_EMBED_FOCUS_IN,
 
154
                                       detail);
 
155
}
 
156
 
 
157
void
 
158
_gtk_socket_windowing_send_configure_event (GtkSocket *socket)
 
159
{
 
160
  /* XXX Nothing needed? */
 
161
}
 
162
 
 
163
void
 
164
_gtk_socket_windowing_select_plug_window_input (GtkSocket *socket)
 
165
{
 
166
  /* XXX Nothing needed? */
 
167
}
 
168
 
 
169
void
 
170
_gtk_socket_windowing_embed_get_info (GtkSocket *socket)
 
171
{
 
172
  socket->is_mapped = TRUE;     /* XXX ? */
 
173
}
 
174
 
 
175
void
 
176
_gtk_socket_windowing_embed_notify (GtkSocket *socket)
 
177
{
 
178
  /* XXX Nothing needed? */
 
179
}
 
180
 
 
181
gboolean
 
182
_gtk_socket_windowing_embed_get_focus_wrapped (void)
 
183
{
 
184
  return _gtk_win32_embed_get_focus_wrapped ();
 
185
}
 
186
 
 
187
void
 
188
_gtk_socket_windowing_embed_set_focus_wrapped (void)
 
189
{
 
190
  _gtk_win32_embed_set_focus_wrapped ();
 
191
}
 
192
 
 
193
GdkFilterReturn
 
194
_gtk_socket_windowing_filter_func (GdkXEvent *gdk_xevent,
 
195
                                   GdkEvent  *event,
 
196
                                   gpointer   data)
 
197
{
 
198
  GtkSocket *socket;
 
199
  GtkWidget *widget;
 
200
  MSG *msg;
 
201
  GdkFilterReturn return_val;
 
202
 
 
203
  socket = GTK_SOCKET (data);
 
204
 
 
205
  return_val = GDK_FILTER_CONTINUE;
 
206
 
 
207
  if (socket->plug_widget)
 
208
    return return_val;
 
209
 
 
210
  widget = GTK_WIDGET (socket);
 
211
  msg = (MSG *) gdk_xevent;
 
212
 
 
213
  switch (msg->message)
 
214
    {
 
215
    default:
 
216
      if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_PARENT_NOTIFY))
 
217
        {
 
218
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: PARENT_NOTIFY received window=%#x version=%ld\n", msg->wParam, msg->lParam));
 
219
          /* If we some day different protocols deployed need to add
 
220
           * some more elaborate version handshake
 
221
           */
 
222
          if (msg->lParam != GTK_WIN32_EMBED_PROTOCOL_VERSION)
 
223
            g_warning ("GTK Win32 embedding protocol version mismatch, "
 
224
                       "client uses version %ld, we understand version %d",
 
225
                       msg->lParam, GTK_WIN32_EMBED_PROTOCOL_VERSION);
 
226
          if (!socket->plug_window)
 
227
            {
 
228
              _gtk_socket_add_window (socket, msg->wParam, FALSE);
 
229
              
 
230
              if (socket->plug_window)
 
231
                GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: window created"));
 
232
              
 
233
              return_val = GDK_FILTER_REMOVE;
 
234
            }
 
235
        }
 
236
      else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_EVENT_PLUG_MAPPED))
 
237
        {
 
238
          gboolean was_mapped = socket->is_mapped;
 
239
          gboolean is_mapped = msg->wParam != 0;
 
240
 
 
241
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: PLUG_MAPPED received is_mapped:%d\n", is_mapped));
 
242
          if (was_mapped != is_mapped)
 
243
            {
 
244
              if (is_mapped)
 
245
                _gtk_socket_handle_map_request (socket);
 
246
              else
 
247
                {
 
248
                  gdk_window_show (socket->plug_window);
 
249
                  _gtk_socket_unmap_notify (socket);
 
250
                }
 
251
            }
 
252
          return_val = GDK_FILTER_REMOVE;
 
253
        }
 
254
      else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_PLUG_RESIZED))
 
255
        {
 
256
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: PLUG_RESIZED received\n"));
 
257
          socket->have_size = FALSE;
 
258
          gtk_widget_queue_resize (widget);
 
259
          return_val = GDK_FILTER_REMOVE;
 
260
        }
 
261
      else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_REQUEST_FOCUS))
 
262
        {
 
263
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: REQUEST_FOCUS received\n"));
 
264
          _gtk_win32_embed_push_message (msg);
 
265
          _gtk_socket_claim_focus (socket, TRUE);
 
266
          _gtk_win32_embed_pop_message ();
 
267
          return_val = GDK_FILTER_REMOVE;
 
268
        }
 
269
      else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_NEXT))
 
270
        {
 
271
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: FOCUS_NEXT received\n"));
 
272
          _gtk_win32_embed_push_message (msg);
 
273
          _gtk_socket_advance_toplevel_focus (socket, GTK_DIR_TAB_FORWARD);
 
274
          _gtk_win32_embed_pop_message ();
 
275
          return_val = GDK_FILTER_REMOVE;
 
276
        }
 
277
      else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_FOCUS_PREV))
 
278
        {
 
279
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: FOCUS_PREV received\n"));
 
280
          _gtk_win32_embed_push_message (msg);
 
281
          _gtk_socket_advance_toplevel_focus (socket, GTK_DIR_TAB_BACKWARD);
 
282
          _gtk_win32_embed_pop_message ();
 
283
          return_val = GDK_FILTER_REMOVE;
 
284
        }
 
285
      else if (msg->message == _gtk_win32_embed_message_type (GTK_WIN32_EMBED_GRAB_KEY))
 
286
        {
 
287
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: GRAB_KEY received\n"));
 
288
          _gtk_win32_embed_push_message (msg);
 
289
          _gtk_socket_add_grabbed_key (socket, msg->wParam, msg->lParam);
 
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_UNGRAB_KEY))
 
294
        {
 
295
          GTK_NOTE (PLUGSOCKET, g_printerr ("GtkSocket: UNGRAB_KEY received\n"));
 
296
          _gtk_win32_embed_push_message (msg);
 
297
          _gtk_socket_remove_grabbed_key (socket, msg->wParam, msg->lParam);
 
298
          _gtk_win32_embed_pop_message ();
 
299
          return_val = GDK_FILTER_REMOVE;
 
300
        }
 
301
      break;
 
302
    }
 
303
 
 
304
  return return_val;
 
305
}
 
306