1 /* GDK - The GIMP Drawing Kit
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
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 */
19
20 /*
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team.
23 */
24
25 /*
26 * GTK+ DirectFB backend
27 * Copyright (C) 2001-2002 convergence integrated media GmbH
28 * Copyright (C) 2002-2004 convergence GmbH
29 * Written by Denis Oliver Kropp <dok@convergence.de> and
30 * Sven Neumann <sven@convergence.de>
31 */
32
33 #include "config.h"
34 #include "gdk.h"
35 #include "gdkdirectfb.h"
36 #include "gdkprivate-directfb.h"
37
38 #include "gdkinternals.h"
39
40 #include "gdkkeysyms.h"
41
42 #include "gdkinput-directfb.h"
43 #include <string.h>
44
45 #ifndef __GDK_X_H__
46 #define __GDK_X_H__
47 gboolean gdk_net_wm_supports (GdkAtom property);
48 #endif
49
50 #include "gdkalias.h"
51
52 #define EventBuffer _gdk_display->buffer
53 #define DirectFB _gdk_display->directfb
54
55 #include "gdkaliasdef.c"
56
57 D_DEBUG_DOMAIN (GDKDFB_Events, "GDKDFB/Events", "GDK DirectFB Events");
58 D_DEBUG_DOMAIN (GDKDFB_MouseEvents, "GDKDFB/Events/Mouse", "GDK DirectFB Mouse Events");
59 D_DEBUG_DOMAIN (GDKDFB_WindowEvents, "GDKDFB/Events/Window", "GDK DirectFB Window Events");
60 D_DEBUG_DOMAIN (GDKDFB_KeyEvents, "GDKDFB/Events/Key", "GDK DirectFB Key Events");
61
62 /*********************************************
63 * Functions for maintaining the event queue *
64 *********************************************/
65
66 static gboolean gdk_event_translate (GdkEvent *event,
67 DFBWindowEvent *dfbevent,
68 GdkWindow *window);
69
70 /*
71 * Private variable declarations
72 */
73 static GList *client_filters; /* Filters for client messages */
74
75 static gint
gdk_event_apply_filters(DFBWindowEvent * dfbevent,GdkEvent * event,GList * filters)76 gdk_event_apply_filters (DFBWindowEvent *dfbevent,
77 GdkEvent *event,
78 GList *filters)
79 {
80 GList *tmp_list;
81 GdkFilterReturn result;
82
83 tmp_list = filters;
84
85 while (tmp_list)
86 {
87 GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;
88
89 tmp_list = tmp_list->next;
90 result = filter->function (dfbevent, event, filter->data);
91 if (result != GDK_FILTER_CONTINUE)
92 return result;
93 }
94
95 return GDK_FILTER_CONTINUE;
96 }
97
98 static void
dfb_events_process_window_event(DFBWindowEvent * dfbevent)99 dfb_events_process_window_event (DFBWindowEvent *dfbevent)
100 {
101 GdkDisplay *display = gdk_display_get_default ();
102 GdkWindow *window;
103 GdkEvent *event;
104 GList *node;
105
106 window = gdk_directfb_window_id_table_lookup (dfbevent->window_id);
107 if (!window)
108 return;
109
110 event = gdk_event_new (GDK_NOTHING);
111
112 event->any.window = NULL;
113
114 ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
115
116 node = _gdk_event_queue_append (display, event);
117
118 if (gdk_event_translate (event, dfbevent, window))
119 {
120 ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
121 _gdk_windowing_got_event (display, node, event, 0);
122 }
123 else
124 {
125 _gdk_event_queue_remove_link (display, node);
126 g_list_free_1 (node);
127 gdk_event_free (event);
128 }
129 }
130
131 static gboolean
gdk_event_send_client_message_by_window(GdkEvent * event,GdkWindow * window)132 gdk_event_send_client_message_by_window (GdkEvent *event,
133 GdkWindow *window)
134 {
135 DFBUserEvent evt;
136
137 g_return_val_if_fail(event != NULL, FALSE);
138 g_return_val_if_fail(GDK_IS_WINDOW(window), FALSE);
139
140 evt.clazz = DFEC_USER;
141 evt.type = GPOINTER_TO_UINT (GDK_ATOM_TO_POINTER (event->client.message_type));
142 evt.data = (void *) event->client.data.l[0];
143
144 _gdk_display->buffer->PostEvent (_gdk_display->buffer, DFB_EVENT (&evt));
145
146 return TRUE;
147 }
148
149 static void
dfb_events_dispatch(void)150 dfb_events_dispatch (void)
151 {
152 GdkDisplay *display = gdk_display_get_default ();
153 GdkEvent *event;
154
155 GDK_THREADS_ENTER ();
156
157 while ((event = _gdk_event_unqueue (display)) != NULL)
158 {
159 if (_gdk_event_func)
160 (*_gdk_event_func) (event, _gdk_event_data);
161
162 gdk_event_free (event);
163 }
164
165 GDK_THREADS_LEAVE ();
166 }
167
168 static gboolean
dfb_events_io_func(GIOChannel * channel,GIOCondition condition,gpointer data)169 dfb_events_io_func (GIOChannel *channel,
170 GIOCondition condition,
171 gpointer data)
172 {
173 gsize i;
174 gsize read;
175 GIOStatus result;
176 DFBEvent buf[23];
177 DFBEvent *event;
178
179 result = g_io_channel_read_chars (channel,
180 (gchar *) buf, sizeof (buf), &read, NULL);
181
182 if (result == G_IO_STATUS_ERROR)
183 {
184 g_warning ("%s: GIOError occured", G_STRFUNC);
185 return TRUE;
186 }
187
188 read /= sizeof (DFBEvent);
189
190 for (i = 0, event = buf; i < read; i++, event++)
191 {
192 switch (event->clazz)
193 {
194 case DFEC_WINDOW:
195 /* TODO workaround to prevent two DWET_ENTER in a row from being delivered */
196 if (event->window.type == DWET_ENTER) {
197 if (i > 0 && buf[i - 1].window.type != DWET_ENTER)
198 dfb_events_process_window_event (&event->window);
199 }
200 else
201 dfb_events_process_window_event (&event->window);
202 break;
203
204 case DFEC_USER:
205 {
206 GList *list;
207
208 GDK_NOTE (EVENTS, g_print (" client_message"));
209
210 for (list = client_filters; list; list = list->next)
211 {
212 GdkClientFilter *filter = list->data;
213 DFBUserEvent *user_event = (DFBUserEvent *) event;
214 GdkAtom type;
215
216 type = GDK_POINTER_TO_ATOM (GUINT_TO_POINTER (user_event->type));
217
218 if (filter->type == type)
219 {
220 if (filter->function (user_event,
221 NULL,
222 filter->data) != GDK_FILTER_CONTINUE)
223 break;
224 }
225 }
226 }
227 break;
228
229 default:
230 break;
231 }
232 }
233
234 EventBuffer->Reset (EventBuffer);
235
236 dfb_events_dispatch ();
237
238 return TRUE;
239 }
240
241 void
_gdk_events_init(void)242 _gdk_events_init (void)
243 {
244 GIOChannel *channel;
245 GSource *source;
246 DFBResult ret;
247 gint fd;
248
249 ret = DirectFB->CreateEventBuffer (DirectFB, &EventBuffer);
250 if (ret)
251 {
252 DirectFBError ("_gdk_events_init: "
253 "IDirectFB::CreateEventBuffer() failed", ret);
254 return;
255 }
256
257 ret = EventBuffer->CreateFileDescriptor (EventBuffer, &fd);
258 if (ret)
259 {
260 DirectFBError ("_gdk_events_init: "
261 "IDirectFBEventBuffer::CreateFileDescriptor() failed",
262 ret);
263 return;
264 }
265
266 channel = g_io_channel_unix_new (fd);
267
268 g_io_channel_set_encoding (channel, NULL, NULL);
269 g_io_channel_set_buffered (channel, FALSE);
270
271 source = g_io_create_watch (channel, G_IO_IN);
272
273 g_source_set_priority (source, G_PRIORITY_DEFAULT);
274 g_source_set_can_recurse (source, TRUE);
275 g_source_set_callback (source, (GSourceFunc) dfb_events_io_func, NULL, NULL);
276
277 g_source_attach (source, NULL);
278 g_source_unref (source);
279 }
280
281 gboolean
gdk_events_pending(void)282 gdk_events_pending (void)
283 {
284 GdkDisplay *display = gdk_display_get_default ();
285
286 return _gdk_event_queue_find_first (display) ? TRUE : FALSE;
287 }
288
289 GdkEvent *
gdk_event_get_graphics_expose(GdkWindow * window)290 gdk_event_get_graphics_expose (GdkWindow *window)
291 {
292 GdkDisplay *display;
293 GList *list;
294
295 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
296
297 display = gdk_drawable_get_display (GDK_DRAWABLE (window));
298
299 for (list = _gdk_event_queue_find_first (display); list; list = list->next)
300 {
301 GdkEvent *event = list->data;
302 if (event->type == GDK_EXPOSE && event->expose.window == window)
303 break;
304 }
305
306 if (list)
307 {
308 GdkEvent *retval = list->data;
309
310 _gdk_event_queue_remove_link (display, list);
311 g_list_free_1 (list);
312
313 return retval;
314 }
315
316 return NULL;
317 }
318
319 void
_gdk_events_queue(GdkDisplay * display)320 _gdk_events_queue (GdkDisplay *display)
321 {
322 }
323
324 void
gdk_flush(void)325 gdk_flush (void)
326 {
327 gdk_display_flush (GDK_DISPLAY_OBJECT (_gdk_display));
328 }
329
330 /* Sends a ClientMessage to all toplevel client windows */
331 gboolean
gdk_event_send_client_message_for_display(GdkDisplay * display,GdkEvent * event,guint32 xid)332 gdk_event_send_client_message_for_display (GdkDisplay *display,
333 GdkEvent *event,
334 guint32 xid)
335 {
336 GdkWindow *win = NULL;
337 gboolean ret = TRUE;
338
339 g_return_val_if_fail (event != NULL, FALSE);
340
341 win = gdk_window_lookup_for_display (display, (GdkNativeWindow) xid);
342
343 g_return_val_if_fail (win != NULL, FALSE);
344
345 if ((GDK_WINDOW_OBJECT (win)->window_type != GDK_WINDOW_CHILD) &&
346 (g_object_get_data (G_OBJECT (win), "gdk-window-child-handler")))
347 {
348 /* Managed window, check children */
349 GList *ltmp = NULL;
350 for (ltmp = GDK_WINDOW_OBJECT (win)->children; ltmp; ltmp = ltmp->next)
351 {
352 ret &= gdk_event_send_client_message_by_window (event,
353 GDK_WINDOW(ltmp->data));
354 }
355 }
356 else
357 {
358 ret &= gdk_event_send_client_message_by_window (event, win);
359 }
360
361 return ret;
362 }
363
364 /*****/
365
366 guint32
gdk_directfb_get_time(void)367 gdk_directfb_get_time (void)
368 {
369 GTimeVal tv;
370
371 g_get_current_time (&tv);
372
373 return (guint32) tv.tv_sec * 1000 + tv.tv_usec / 1000;
374 }
375
376 void
gdk_directfb_event_windows_add(GdkWindow * window)377 gdk_directfb_event_windows_add (GdkWindow *window)
378 {
379 GdkWindowImplDirectFB *impl;
380
381 g_return_if_fail (GDK_IS_WINDOW (window));
382
383 impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
384
385 if (!impl->window)
386 return;
387
388 if (EventBuffer)
389 impl->window->AttachEventBuffer (impl->window, EventBuffer);
390 else
391 impl->window->CreateEventBuffer (impl->window, &EventBuffer);
392 }
393
394 void
gdk_directfb_event_windows_remove(GdkWindow * window)395 gdk_directfb_event_windows_remove (GdkWindow *window)
396 {
397 GdkWindowImplDirectFB *impl;
398
399 g_return_if_fail (GDK_IS_WINDOW (window));
400
401 impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
402
403 if (!impl->window)
404 return;
405
406 if (EventBuffer)
407 impl->window->DetachEventBuffer (impl->window, EventBuffer);
408 /* FIXME: should we warn if (! EventBuffer) ? */
409 }
410
411 GdkWindow *
gdk_directfb_child_at(GdkWindow * window,gint * winx,gint * winy)412 gdk_directfb_child_at (GdkWindow *window,
413 gint *winx,
414 gint *winy)
415 {
416 GdkWindowObject *private;
417 GList *list;
418
419 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
420
421 private = GDK_WINDOW_OBJECT (window);
422 for (list = private->children; list; list = list->next)
423 {
424 GdkWindowObject *win = list->data;
425 gint wx, wy, ww, wh;
426
427 gdk_window_get_geometry (GDK_WINDOW (win), &wx, &wy, &ww, &wh, NULL);
428
429 if (GDK_WINDOW_IS_MAPPED (win) &&
430 *winx >= wx && *winx < wx + ww &&
431 *winy >= wy && *winy < wy + wh)
432 {
433 *winx -= win->x;
434 *winy -= win->y;
435
436 return gdk_directfb_child_at (GDK_WINDOW (win), winx, winy);
437 }
438 }
439
440 return window;
441 }
442
443 static gboolean
gdk_event_translate(GdkEvent * event,DFBWindowEvent * dfbevent,GdkWindow * window)444 gdk_event_translate (GdkEvent *event,
445 DFBWindowEvent *dfbevent,
446 GdkWindow *window)
447 {
448 GdkWindowObject *private;
449 GdkDisplay *display;
450 /* GdkEvent *event = NULL; */
451 gboolean return_val = FALSE;
452
453 g_return_val_if_fail (event != NULL, FALSE);
454 g_return_val_if_fail (dfbevent != NULL, FALSE);
455 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
456
457 D_DEBUG_AT (GDKDFB_Events, "%s( %p, %p, %p )\n", G_STRFUNC,
458 event, dfbevent, window);
459
460 private = GDK_WINDOW_OBJECT (window);
461
462 g_object_ref (G_OBJECT (window));
463
464 event->any.window = NULL;
465 event->any.send_event = FALSE;
466
467 /*
468 * Apply global filters
469 *
470 * If result is GDK_FILTER_CONTINUE, we continue as if nothing
471 * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,
472 * we return TRUE and won't dispatch the event.
473 */
474 if (_gdk_default_filters)
475 {
476 GdkFilterReturn result;
477 result = gdk_event_apply_filters (dfbevent, event, _gdk_default_filters);
478
479 if (result != GDK_FILTER_CONTINUE)
480 {
481 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
482 goto done;
483 }
484 }
485
486 /* Apply per-window filters */
487 if (GDK_IS_WINDOW (window))
488 {
489 GdkFilterReturn result;
490
491 if (private->filters)
492 {
493 result = gdk_event_apply_filters (dfbevent, event, private->filters);
494
495 if (result != GDK_FILTER_CONTINUE)
496 {
497 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
498 goto done;
499 }
500 }
501 }
502
503 display = gdk_drawable_get_display (GDK_DRAWABLE (window));
504
505 return_val = TRUE;
506
507 switch (dfbevent->type)
508 {
509 case DWET_BUTTONDOWN:
510 case DWET_BUTTONUP:
511 /* Backend store */
512 _gdk_directfb_mouse_x = dfbevent->cx;
513 _gdk_directfb_mouse_y = dfbevent->cy;
514
515 /* Event translation */
516 gdk_directfb_event_fill (event, window,
517 dfbevent->type == DWET_BUTTONDOWN ?
518 GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
519 switch (dfbevent->button)
520 {
521 case DIBI_LEFT:
522 event->button.button = 1;
523 break;
524
525 case DIBI_MIDDLE:
526 event->button.button = 2;
527 break;
528
529 case DIBI_RIGHT:
530 event->button.button = 3;
531 break;
532
533 default:
534 event->button.button = dfbevent->button + 1;
535 break;
536 }
537
538 event->button.window = window;
539 event->button.x_root = dfbevent->cx;
540 event->button.y_root = dfbevent->cy;
541 event->button.x = dfbevent->x;
542 event->button.y = dfbevent->y;
543 event->button.state = _gdk_directfb_modifiers;
544 event->button.device = display->core_pointer;
545 gdk_event_set_screen (event, _gdk_screen);
546
547 D_DEBUG_AT (GDKDFB_MouseEvents, " -> %s at %ix%i\n",
548 event->type == GDK_BUTTON_PRESS ? "buttonpress" : "buttonrelease",
549 (gint) event->button.x, (gint) event->button.y);
550 break;
551
552 case DWET_MOTION:
553 /* Backend store */
554 _gdk_directfb_mouse_x = dfbevent->cx;
555 _gdk_directfb_mouse_y = dfbevent->cy;
556
557 /* Event translation */
558 gdk_directfb_event_fill (event, window, GDK_MOTION_NOTIFY);
559 event->motion.x_root = dfbevent->cx;
560 event->motion.y_root = dfbevent->cy;
561 event->motion.x = dfbevent->x;
562 event->motion.y = dfbevent->y;
563 event->motion.axes = NULL;
564 event->motion.state = _gdk_directfb_modifiers;
565 event->motion.is_hint = FALSE;
566 event->motion.device = display->core_pointer;
567 gdk_event_set_screen (event, _gdk_screen);
568
569 D_DEBUG_AT (GDKDFB_MouseEvents, " -> move pointer to %ix%i\n",
570 (gint) event->button.x, (gint) event->button.y);
571 break;
572
573 case DWET_GOTFOCUS:
574 gdk_directfb_event_fill (event, window, GDK_FOCUS_CHANGE);
575 event->focus_change.window = window;
576 event->focus_change.in = TRUE;
577 break;
578
579 case DWET_LOSTFOCUS:
580 gdk_directfb_event_fill (event, window, GDK_FOCUS_CHANGE);
581 event->focus_change.window = window;
582 event->focus_change.in = FALSE;
583 break;
584
585 case DWET_POSITION:
586 gdk_directfb_event_fill (event, window, GDK_CONFIGURE);
587 event->configure.x = dfbevent->x;
588 event->configure.y = dfbevent->y;
589 event->configure.width = private->width;
590 event->configure.height = private->height;
591 break;
592
593 case DWET_POSITION_SIZE:
594 event->configure.x = dfbevent->x;
595 event->configure.y = dfbevent->y;
596 /* fallthru */
597
598 case DWET_SIZE:
599 gdk_directfb_event_fill (event, window, GDK_CONFIGURE);
600 event->configure.window = window;
601 event->configure.width = dfbevent->w;
602 event->configure.height = dfbevent->h;
603
604 D_DEBUG_AT (GDKDFB_WindowEvents,
605 " -> configure window %p at %ix%i-%ix%i\n",
606 window, event->configure.x, event->configure.y,
607 event->configure.width, event->configure.height);
608 break;
609
610 case DWET_KEYDOWN:
611 case DWET_KEYUP:
612 gdk_directfb_event_fill (event, window,
613 dfbevent->type == DWET_KEYUP ?
614 GDK_KEY_RELEASE : GDK_KEY_PRESS);
615 event->key.window = window;
616 gdk_directfb_translate_key_event (dfbevent, (GdkEventKey *) event);
617
618 D_DEBUG_AT (GDKDFB_KeyEvents, " -> key window=%p val=%x code=%x str=%s\n",
619 window, event->key.keyval, event->key.hardware_keycode,
620 event->key.string);
621 break;
622
623 case DWET_ENTER:
624 case DWET_LEAVE:
625 /* Backend store */
626 _gdk_directfb_mouse_x = dfbevent->cx;
627 _gdk_directfb_mouse_y = dfbevent->cy;
628
629 /* Event translation */
630 gdk_directfb_event_fill (event, window,
631 dfbevent->type == DWET_ENTER ?
632 GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
633 event->crossing.window = g_object_ref (window);
634 event->crossing.subwindow = NULL;
635 event->crossing.time = GDK_CURRENT_TIME;
636 event->crossing.x = dfbevent->x;
637 event->crossing.y = dfbevent->y;
638 event->crossing.x_root = dfbevent->cx;
639 event->crossing.y_root = dfbevent->cy;
640 event->crossing.mode = GDK_CROSSING_NORMAL;
641 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
642 event->crossing.state = 0;
643
644 /**/
645 if (gdk_directfb_apply_focus_opacity)
646 {
647 if (dfbevent->type == DWET_ENTER)
648 {
649 if (GDK_WINDOW_IS_MAPPED (window))
650 GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
651 (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
652 (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 1) +
653 (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 2));
654 }
655 else
656 {
657 GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
658 (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
659 GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity);
660 }
661 }
662
663 D_DEBUG_AT (GDKDFB_WindowEvents, " -> %s window %p at relative=%ix%i absolute=%ix%i\n",
664 dfbevent->type == DWET_ENTER ? "enter" : "leave",
665 window, (gint) event->crossing.x, (gint) event->crossing.y,
666 (gint) event->crossing.x_root, (gint) event->crossing.y_root);
667 break;
668
669 case DWET_CLOSE:
670 gdk_directfb_event_fill (event, window, GDK_DELETE);
671 break;
672
673 case DWET_DESTROYED:
674 gdk_directfb_event_fill (event, window, GDK_DESTROY);
675 gdk_window_destroy_notify (window);
676 break;
677
678 case DWET_WHEEL:
679 /* Backend store */
680 _gdk_directfb_mouse_x = dfbevent->cx;
681 _gdk_directfb_mouse_y = dfbevent->cy;
682
683 /* Event translation */
684 gdk_directfb_event_fill (event, window, GDK_SCROLL);
685 event->scroll.direction = (dfbevent->step > 0 ?
686 GDK_SCROLL_UP : GDK_SCROLL_DOWN);
687 event->scroll.x_root = dfbevent->cx;
688 event->scroll.y_root = dfbevent->cy;
689 event->scroll.x = dfbevent->x;
690 event->scroll.y = dfbevent->y;
691 event->scroll.state = _gdk_directfb_modifiers;
692 event->scroll.device = display->core_pointer;
693
694 D_DEBUG_AT (GDKDFB_MouseEvents, " -> mouse scroll %s at %ix%i\n",
695 event->scroll.direction == GDK_SCROLL_UP ? "up" : "down",
696 (gint) event->scroll.x, (gint) event->scroll.y);
697 break;
698
699 default:
700 g_message ("unhandled DirectFB windowing event 0x%08x", dfbevent->type);
701 }
702
703 done:
704
705 g_object_unref (G_OBJECT (window));
706
707 return return_val;
708 }
709
710 gboolean
gdk_screen_get_setting(GdkScreen * screen,const gchar * name,GValue * value)711 gdk_screen_get_setting (GdkScreen *screen,
712 const gchar *name,
713 GValue *value)
714 {
715 return FALSE;
716 }
717
718 void
gdk_display_add_client_message_filter(GdkDisplay * display,GdkAtom message_type,GdkFilterFunc func,gpointer data)719 gdk_display_add_client_message_filter (GdkDisplay *display,
720 GdkAtom message_type,
721 GdkFilterFunc func,
722 gpointer data)
723 {
724 /* XXX: display should be used */
725 GdkClientFilter *filter = g_new (GdkClientFilter, 1);
726
727 filter->type = message_type;
728 filter->function = func;
729 filter->data = data;
730 client_filters = g_list_append (client_filters, filter);
731 }
732
733
734 void
gdk_add_client_message_filter(GdkAtom message_type,GdkFilterFunc func,gpointer data)735 gdk_add_client_message_filter (GdkAtom message_type,
736 GdkFilterFunc func,
737 gpointer data)
738 {
739 gdk_display_add_client_message_filter (gdk_display_get_default (),
740 message_type, func, data);
741 }
742
743 void
gdk_screen_broadcast_client_message(GdkScreen * screen,GdkEvent * sev)744 gdk_screen_broadcast_client_message (GdkScreen *screen,
745 GdkEvent *sev)
746 {
747 GdkWindow *root_window;
748 GdkWindowObject *private;
749 GList *top_level = NULL;
750
751 g_return_if_fail (GDK_IS_SCREEN (screen));
752 g_return_if_fail (sev != NULL);
753
754 root_window = gdk_screen_get_root_window (screen);
755
756 g_return_if_fail (GDK_IS_WINDOW (root_window));
757
758 private = GDK_WINDOW_OBJECT (root_window);
759
760 for (top_level = private->children; top_level; top_level = top_level->next)
761 {
762 gdk_event_send_client_message_for_display (gdk_drawable_get_display (GDK_DRAWABLE (root_window)),
763 sev,
764 (guint32)(GDK_WINDOW_DFB_ID (GDK_WINDOW (top_level->data))));
765 }
766 }
767
768
769 /**
770 * gdk_net_wm_supports:
771 * @property: a property atom.
772 *
773 * This function is specific to the X11 backend of GDK, and indicates
774 * whether the window manager for the default screen supports a certain
775 * hint from the Extended Window Manager Hints Specification. See
776 * gdk_x11_screen_supports_net_wm_hint() for complete details.
777 *
778 * Return value: %TRUE if the window manager supports @property
779 **/
780
781
782 gboolean
gdk_net_wm_supports(GdkAtom property)783 gdk_net_wm_supports (GdkAtom property)
784 {
785 return FALSE;
786 }
787
788 void
_gdk_windowing_event_data_copy(const GdkEvent * src,GdkEvent * dst)789 _gdk_windowing_event_data_copy (const GdkEvent *src,
790 GdkEvent *dst)
791 {
792 }
793
794 void
_gdk_windowing_event_data_free(GdkEvent * event)795 _gdk_windowing_event_data_free (GdkEvent *event)
796 {
797 }
798
799 #define __GDK_EVENTS_X11_C__
800 #include "gdkaliasdef.c"
801