Pileus Git - ~andy/gtk/blob - gdk/directfb/gdkevents-directfb.c

   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
  56
  57
  58 #include "gdkaliasdef.c"
  59
  60 /*********************************************
  61  * Functions for maintaining the event queue *
  62  *********************************************/
  63
  64 static GdkEvent * gdk_event_translate  (DFBWindowEvent  *dfbevent,
  65                                         GdkWindow       *window);
  66
  67 /*
  68  * Private variable declarations
  69  */
  70 static GList *client_filters;  /* Filters for client messages */
  71
  72
  73 static void
  74 fixup_event (GdkEvent *event)
  75 {
  76   if (event->any.window)
  77     g_object_ref (event->any.window);
  78   if (((event->any.type == GDK_ENTER_NOTIFY) ||
  79        (event->any.type == GDK_LEAVE_NOTIFY)) &&
  80       (event->crossing.subwindow != NULL))
  81     g_object_ref (event->crossing.subwindow);
  82   event->any.send_event = FALSE;
  83 }
  84
  85 static GdkFilterReturn
  86 apply_filters (GdkWindow      *window,
  87                DFBWindowEvent *dfbevent,
  88                GList          *filters)
  89 {
  90   GdkFilterReturn result = GDK_FILTER_CONTINUE;
  91   GdkEvent *event;
  92   GList *node;
  93   GList *tmp_list;
  94
  95   event = gdk_event_new (GDK_NOTHING);
  96   if (window != NULL)
  97     event->any.window = g_object_ref (window);
  98   ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
  99
 100   /* I think GdkFilterFunc semantics require the passed-in event
 101    * to already be in the queue. The filter func can generate
 102    * more events and append them after it if it likes.
 103    */
 104   node = _gdk_event_queue_append ((GdkDisplay*)_gdk_display, event);
 105
 106   tmp_list = filters;
 107   while (tmp_list)
 108     {
 109       GdkEventFilter *filter = (GdkEventFilter *) tmp_list->data;
 110
 111       tmp_list = tmp_list->next;
 112       result = filter->function (dfbevent, event, filter->data);
 113       if (result != GDK_FILTER_CONTINUE)
 114         break;
 115     }
 116
 117   if (result == GDK_FILTER_CONTINUE || result == GDK_FILTER_REMOVE)
 118     {
 119       _gdk_event_queue_remove_link ((GdkDisplay*)_gdk_display, node);
 120       g_list_free_1 (node);
 121       gdk_event_free (event);
 122     }
 123   else /* GDK_FILTER_TRANSLATE */
 124     {
 125       ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
 126       fixup_event (event);
 127     }
 128   return result;
 129 }
 130
 131 static void
 132 dfb_events_process_window_event (DFBWindowEvent *event)
 133 {
 134   GdkWindow *window;
 135
 136   /*
 137    * Apply global filters
 138    *
 139    * If result is GDK_FILTER_CONTINUE, we continue as if nothing
 140    * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,
 141    * we return TRUE and won't dispatch the event.
 142    */
 143   if (_gdk_default_filters)
 144     {
 145       switch (apply_filters (NULL, event, _gdk_default_filters))
 146         {
 147         case GDK_FILTER_REMOVE:
 148         case GDK_FILTER_TRANSLATE:
 149           return;
 150
 151         default:
 152           break;
 153         }
 154     }
 155
 156   window = gdk_directfb_window_id_table_lookup (event->window_id);
 157   if (!window)
 158     return;
 159
 160   gdk_event_translate (event, window);
 161 }
 162
 163 static gboolean
 164 gdk_event_send_client_message_by_window (GdkEvent *event,
 165                                          GdkWindow *window)
 166 {
 167   DFBUserEvent evt;
 168
 169   g_return_val_if_fail(event != NULL, FALSE);
 170   g_return_val_if_fail(GDK_IS_WINDOW(window), FALSE);
 171
 172   evt.clazz = DFEC_USER;
 173   evt.type = GPOINTER_TO_UINT (GDK_ATOM_TO_POINTER (event->client.message_type));
 174   evt.data = (void *) event->client.data.l[0];
 175
 176   _gdk_display->buffer->PostEvent(_gdk_display->buffer, DFB_EVENT (&evt));
 177
 178   return TRUE;
 179 }
 180
 181 static void
 182 dfb_events_dispatch (void)
 183 {
 184   GdkDisplay *display = gdk_display_get_default ();
 185   GdkEvent   *event;
 186
 187   while ((event = _gdk_event_unqueue (display)) != NULL)
 188     {
 189       if (_gdk_event_func)
 190         (*_gdk_event_func) (event, _gdk_event_data);
 191
 192       gdk_event_free (event);
 193     }
 194 }
 195
 196 static gboolean
 197 dfb_events_io_func (GIOChannel   *channel,
 198                     GIOCondition  condition,
 199                     gpointer      data)
 200 {
 201   gsize      i;
 202   gsize      read;
 203   GIOStatus  result;
 204   DFBEvent   buf[23];
 205   DFBEvent  *event;
 206
 207   result = g_io_channel_read_chars (channel,
 208                                     (gchar *) buf, sizeof (buf), &read, NULL);
 209
 210   if (result == G_IO_STATUS_ERROR)
 211     {
 212       g_warning ("%s: GIOError occured", __FUNCTION__);
 213       return TRUE;
 214     }
 215
 216   read /= sizeof (DFBEvent);
 217
 218   for (i = 0, event = buf; i < read; i++, event++)
 219     {
 220       switch (event->clazz)
 221         {
 222         case DFEC_WINDOW:
 223           /* TODO workaround to prevent two DWET_ENTER in a row from being delivered */
 224           if (event->window.type == DWET_ENTER ) {
 225             if ( i>0 && buf[i-1].window.type != DWET_ENTER )
 226               dfb_events_process_window_event (&event->window);
 227           }
 228           else
 229             dfb_events_process_window_event (&event->window);
 230           break;
 231
 232         case DFEC_USER:
 233           {
 234             GList *list;
 235
 236             GDK_NOTE (EVENTS, g_print (" client_message"));
 237
 238             for (list = client_filters; list; list = list->next)
 239               {
 240                 GdkClientFilter *filter     = list->data;
 241                 DFBUserEvent    *user_event = (DFBUserEvent *) event;
 242                 GdkAtom          type;
 243
 244                 type = GDK_POINTER_TO_ATOM (GUINT_TO_POINTER (user_event->type));
 245
 246                 if (filter->type == type)
 247                   {
 248                     if (filter->function (user_event,
 249                                           NULL,
 250                                           filter->data) != GDK_FILTER_CONTINUE)
 251                       break;
 252                   }
 253               }
 254           }
 255           break;
 256
 257         default:
 258           break;
 259         }
 260     }
 261
 262   EventBuffer->Reset (EventBuffer);
 263
 264   dfb_events_dispatch ();
 265
 266   return TRUE;
 267 }
 268
 269 void
 270 _gdk_events_init (void)
 271 {
 272   GIOChannel *channel;
 273   GSource    *source;
 274   DFBResult   ret;
 275   gint        fd;
 276
 277   ret = DirectFB->CreateEventBuffer (DirectFB, &EventBuffer);
 278   if (ret)
 279     {
 280       DirectFBError ("_gdk_events_init: "
 281                      "IDirectFB::CreateEventBuffer() failed", ret);
 282       return;
 283     }
 284
 285   ret = EventBuffer->CreateFileDescriptor (EventBuffer, &fd);
 286   if (ret)
 287     {
 288       DirectFBError ("_gdk_events_init: "
 289                      "IDirectFBEventBuffer::CreateFileDescriptor() failed",
 290                      ret);
 291       return;
 292     }
 293
 294   channel = g_io_channel_unix_new (fd);
 295
 296   g_io_channel_set_encoding (channel, NULL, NULL);
 297   g_io_channel_set_buffered (channel, FALSE);
 298
 299   source = g_io_create_watch (channel, G_IO_IN);
 300
 301   g_source_set_priority (source, G_PRIORITY_DEFAULT);
 302   g_source_set_can_recurse (source, TRUE);
 303   g_source_set_callback (source, (GSourceFunc) dfb_events_io_func, NULL, NULL);
 304
 305   g_source_attach (source, NULL);
 306   g_source_unref (source);
 307 }
 308
 309 gboolean
 310 gdk_events_pending (void)
 311 {
 312   GdkDisplay *display = gdk_display_get_default ();
 313
 314   return _gdk_event_queue_find_first (display) ? TRUE : FALSE;
 315 }
 316
 317 GdkEvent *
 318 gdk_event_get_graphics_expose (GdkWindow *window)
 319 {
 320   GdkDisplay *display;
 321   GList      *list;
 322
 323   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 324
 325   display = gdk_drawable_get_display (GDK_DRAWABLE (window));
 326
 327   for (list = _gdk_event_queue_find_first (display); list; list = list->next)
 328     {
 329       GdkEvent *event = list->data;
 330       if (event->type == GDK_EXPOSE && event->expose.window == window)
 331         break;
 332     }
 333
 334   if (list)
 335     {
 336       GdkEvent *retval = list->data;
 337
 338       _gdk_event_queue_remove_link (display, list);
 339       g_list_free_1 (list);
 340
 341       return retval;
 342     }
 343
 344   return NULL;
 345 }
 346
 347 void
 348 _gdk_events_queue (GdkDisplay *display)
 349 {
 350 }
 351
 352 void
 353 gdk_flush (void)
 354 {
 355 gdk_display_flush ( GDK_DISPLAY_OBJECT(_gdk_display));
 356 }
 357
 358 /* Sends a ClientMessage to all toplevel client windows */
 359 gboolean
 360 gdk_event_send_client_message_for_display (GdkDisplay *display,
 361                                            GdkEvent   *event,
 362                                            guint32     xid)
 363 {
 364   GdkWindow *win = NULL;
 365   gboolean ret = TRUE;
 366
 367   g_return_val_if_fail(event != NULL, FALSE);
 368
 369   win = gdk_window_lookup_for_display (display, (GdkNativeWindow) xid);
 370
 371   g_return_val_if_fail(win != NULL, FALSE);
 372
 373   if ((GDK_WINDOW_OBJECT(win)->window_type != GDK_WINDOW_CHILD) &&
 374       (g_object_get_data (G_OBJECT (win), "gdk-window-child-handler")))
 375     {
 376       /* Managed window, check children */
 377       GList *ltmp = NULL;
 378       for (ltmp = GDK_WINDOW_OBJECT(win)->children; ltmp; ltmp = ltmp->next)
 379        {
 380          ret &= gdk_event_send_client_message_by_window (event,
 381                                                          GDK_WINDOW(ltmp->data));
 382        }
 383     }
 384   else
 385     {
 386       ret &= gdk_event_send_client_message_by_window (event, win);
 387     }
 388
 389   return ret;
 390 }
 391
 392 /*****/
 393
 394 guint32
 395 gdk_directfb_get_time (void)
 396 {
 397   GTimeVal tv;
 398
 399   g_get_current_time (&tv);
 400
 401   return (guint32) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 402 }
 403
 404 void
 405 gdk_directfb_event_windows_add (GdkWindow *window)
 406 {
 407   GdkWindowImplDirectFB *impl;
 408
 409   g_return_if_fail (GDK_IS_WINDOW (window));
 410
 411   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
 412
 413   if (!impl->window)
 414     return;
 415
 416   if (EventBuffer)
 417     impl->window->AttachEventBuffer (impl->window, EventBuffer);
 418   else
 419     impl->window->CreateEventBuffer (impl->window, &EventBuffer);
 420 }
 421
 422 #if (DIRECTFB_MAJOR_VERSION >= 1)
 423 void
 424 gdk_directfb_event_windows_remove (GdkWindow *window)
 425 {
 426   GdkWindowImplDirectFB *impl;
 427
 428   g_return_if_fail (GDK_IS_WINDOW (window));
 429
 430   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
 431
 432   if (!impl->window)
 433     return;
 434
 435   if (EventBuffer)
 436     impl->window->DetachEventBuffer (impl->window, EventBuffer);
 437 /* FIXME: should we warn if (! EventBuffer) ? */
 438 }
 439 #endif
 440
 441 GdkWindow *
 442 gdk_directfb_child_at (GdkWindow *window,
 443                        gint      *winx,
 444                        gint      *winy)
 445 {
 446   GdkWindowObject *private;
 447   GList           *list;
 448
 449   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 450
 451   private = GDK_WINDOW_OBJECT (window);
 452   for (list = private->children; list; list = list->next)
 453     {
 454       GdkWindowObject *win = list->data;
 455
 456       if (GDK_WINDOW_IS_MAPPED (win) &&
 457           *winx >= win->x  &&
 458           *winx <  win->x + GDK_DRAWABLE_IMPL_DIRECTFB (win->impl)->width  &&
 459           *winy >= win->y  &&
 460           *winy <  win->y + GDK_DRAWABLE_IMPL_DIRECTFB (win->impl)->height)
 461         {
 462           *winx -= win->x;
 463           *winy -= win->y;
 464
 465           return gdk_directfb_child_at (GDK_WINDOW (win), winx, winy );
 466         }
 467     }
 468
 469   return window;
 470 }
 471
 472 static GdkEvent *
 473 gdk_event_translate (DFBWindowEvent *dfbevent,
 474                      GdkWindow      *window)
 475 {
 476   GdkWindowObject *private;
 477   GdkDisplay      *display;
 478   GdkEvent        *event    = NULL;
 479
 480   g_return_val_if_fail (dfbevent != NULL, NULL);
 481   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 482
 483   private = GDK_WINDOW_OBJECT (window);
 484
 485   g_object_ref (G_OBJECT (window));
 486
 487   /*
 488    * Apply per-window filters
 489    *
 490    * If result is GDK_FILTER_CONTINUE, we continue as if nothing
 491    * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,
 492    * we return TRUE and won't dispatch the event.
 493    */
 494   if (private->filters)
 495     {
 496       switch (apply_filters (window, dfbevent, private->filters))
 497         {
 498         case GDK_FILTER_REMOVE:
 499         case GDK_FILTER_TRANSLATE:
 500           g_object_unref (G_OBJECT (window));
 501           return NULL;
 502
 503         default:
 504           break;
 505         }
 506     }
 507
 508   display = gdk_drawable_get_display (GDK_DRAWABLE (window));
 509
 510   switch (dfbevent->type)
 511     {
 512     case DWET_BUTTONDOWN:
 513     case DWET_BUTTONUP:
 514       {
 515         static gboolean  click_grab = FALSE;
 516         GdkWindow       *child;
 517         gint             wx, wy;
 518         guint            mask;
 519         guint            button;
 520
 521         _gdk_directfb_mouse_x = wx = dfbevent->cx;
 522         _gdk_directfb_mouse_y = wy = dfbevent->cy;
 523
 524         switch (dfbevent->button)
 525           {
 526           case DIBI_LEFT:
 527             button = 1;
 528             mask   = GDK_BUTTON1_MASK;
 529             break;
 530           case DIBI_MIDDLE:
 531             button = 2;
 532             mask   = GDK_BUTTON2_MASK;
 533             break;
 534           case DIBI_RIGHT:
 535             button = 3;
 536             mask   = GDK_BUTTON3_MASK;
 537             break;
 538           default:
 539             button = dfbevent->button + 1;
 540             mask   = 0;
 541             break;
 542           }
 543
 544         child = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
 545
 546         if (_gdk_directfb_pointer_grab_window &&
 547             (_gdk_directfb_pointer_grab_events & (dfbevent->type ==
 548                                                   DWET_BUTTONDOWN ?
 549                                                   GDK_BUTTON_PRESS_MASK :
 550                                                   GDK_BUTTON_RELEASE_MASK)) &&
 551             (_gdk_directfb_pointer_grab_owner_events == FALSE ||
 552              child == _gdk_parent_root) )
 553           {
 554             GdkDrawableImplDirectFB *impl;
 555
 556             child = _gdk_directfb_pointer_grab_window;
 557             impl  = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (child)->impl);
 558
 559             dfbevent->x = dfbevent->cx - impl->abs_x;
 560             dfbevent->y = dfbevent->cy - impl->abs_y;
 561           }
 562         else if (!_gdk_directfb_pointer_grab_window ||
 563                  (_gdk_directfb_pointer_grab_owner_events == TRUE))
 564           {
 565             dfbevent->x = wx;
 566             dfbevent->y = wy;
 567           }
 568         else
 569           {
 570             child = NULL;
 571           }
 572
 573         if (dfbevent->type == DWET_BUTTONDOWN)
 574           _gdk_directfb_modifiers |= mask;
 575         else
 576           _gdk_directfb_modifiers &= ~mask;
 577
 578         if (child)
 579           {
 580             event =
 581               gdk_directfb_event_make (child,
 582                                        dfbevent->type == DWET_BUTTONDOWN ?
 583                                        GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 584
 585             event->button.x_root = _gdk_directfb_mouse_x;
 586             event->button.y_root = _gdk_directfb_mouse_y;
 587
 588             event->button.x = dfbevent->x;
 589             event->button.y = dfbevent->y;
 590
 591             event->button.state  = _gdk_directfb_modifiers;
 592             event->button.button = button;
 593             event->button.device = display->core_pointer;
 594
 595             GDK_NOTE (EVENTS,
 596                       g_message ("button: %d at %d,%d %s with state 0x%08x",
 597                                  event->button.button,
 598                                  (int)event->button.x, (int)event->button.y,
 599                                  dfbevent->type == DWET_BUTTONDOWN ?
 600                                  "pressed" : "released",
 601                                  _gdk_directfb_modifiers));
 602
 603             if (dfbevent->type == DWET_BUTTONDOWN)
 604               _gdk_event_button_generate (display, event);
 605           }
 606
 607         /* Handle implicit button grabs: */
 608         if (dfbevent->type == DWET_BUTTONDOWN  &&  !click_grab  &&  child)
 609           {
 610             if (gdk_directfb_pointer_grab (child, FALSE,
 611                                            gdk_window_get_events (child),
 612                                            NULL, NULL,
 613                                            GDK_CURRENT_TIME,
 614                                            TRUE) == GDK_GRAB_SUCCESS)
 615               click_grab = TRUE;
 616           }
 617         else if (dfbevent->type == DWET_BUTTONUP &&
 618                  !(_gdk_directfb_modifiers & (GDK_BUTTON1_MASK |
 619                                               GDK_BUTTON2_MASK |
 620                                               GDK_BUTTON3_MASK)) && click_grab)
 621           {
 622             gdk_directfb_pointer_ungrab (GDK_CURRENT_TIME, TRUE);
 623             click_grab = FALSE;
 624           }
 625       }
 626       break;
 627
 628     case DWET_MOTION:
 629       {
 630         GdkWindow *event_win=NULL;
 631         GdkWindow *child;
 632
 633         _gdk_directfb_mouse_x = dfbevent->cx;
 634         _gdk_directfb_mouse_y = dfbevent->cy;
 635
 636         //child = gdk_directfb_child_at (window, &dfbevent->x, &dfbevent->y);
 637     /* Go all the way to root to catch popup menus */
 638     int wx=_gdk_directfb_mouse_x;
 639     int wy=_gdk_directfb_mouse_y;
 640         child = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
 641
 642     /* first let's see if any cossing event has to be send */
 643     gdk_directfb_window_send_crossing_events (NULL, child, GDK_CROSSING_NORMAL);
 644
 645     /* then dispatch the motion event to the window the cursor it's inside */
 646         event_win = gdk_directfb_pointer_event_window (child, GDK_MOTION_NOTIFY);
 647
 648
 649         if (event_win)
 650           {
 651
 652             if (event_win == _gdk_directfb_pointer_grab_window) {
 653                 GdkDrawableImplDirectFB *impl;
 654
 655                 child = _gdk_directfb_pointer_grab_window;
 656                 impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (child)->impl);
 657
 658                 dfbevent->x = _gdk_directfb_mouse_x - impl->abs_x;
 659                 dfbevent->y = _gdk_directfb_mouse_y - impl->abs_y;
 660               }
 661
 662             event = gdk_directfb_event_make (child, GDK_MOTION_NOTIFY);
 663
 664             event->motion.x_root = _gdk_directfb_mouse_x;
 665             event->motion.y_root = _gdk_directfb_mouse_y;
 666
 667             //event->motion.x = dfbevent->x;
 668             //event->motion.y = dfbevent->y;
 669             event->motion.x = wx;
 670             event->motion.y = wy;
 671
 672             event->motion.state   = _gdk_directfb_modifiers;
 673             event->motion.is_hint = FALSE;
 674             event->motion.device  = display->core_pointer;
 675
 676             if (GDK_WINDOW_OBJECT (event_win)->event_mask &
 677                 GDK_POINTER_MOTION_HINT_MASK)
 678               {
 679                 while (EventBuffer->PeekEvent (EventBuffer,
 680                                                DFB_EVENT (dfbevent)) == DFB_OK
 681                        && dfbevent->type == DWET_MOTION)
 682                   {
 683                     EventBuffer->GetEvent (EventBuffer, DFB_EVENT (dfbevent));
 684                     event->motion.is_hint = TRUE;
 685                   }
 686               }
 687           }
 688           /* make sure crossing events go to the event window found */
 689 /*        GdkWindow *ev_win = ( event_win == NULL ) ? gdk_window_at_pointer (NULL,NULL) :event_win;
 690              gdk_directfb_window_send_crossing_events (NULL,ev_win,GDK_CROSSING_NORMAL);
 691 */
 692       }
 693       break;
 694
 695     case DWET_GOTFOCUS:
 696       gdk_directfb_change_focus (window);
 697
 698       break;
 699
 700     case DWET_LOSTFOCUS:
 701       gdk_directfb_change_focus (_gdk_parent_root);
 702
 703       break;
 704
 705     case DWET_POSITION:
 706       {
 707         GdkWindow *event_win;
 708
 709         private->x = dfbevent->x;
 710         private->y = dfbevent->y;
 711
 712         event_win = gdk_directfb_other_event_window (window, GDK_CONFIGURE);
 713
 714         if (event_win)
 715           {
 716             event = gdk_directfb_event_make (event_win, GDK_CONFIGURE);
 717             event->configure.x = dfbevent->x;
 718             event->configure.y = dfbevent->y;
 719             event->configure.width =
 720               GDK_DRAWABLE_IMPL_DIRECTFB (private->impl)->width;
 721             event->configure.height =
 722               GDK_DRAWABLE_IMPL_DIRECTFB (private->impl)->height;
 723           }
 724
 725         _gdk_directfb_calc_abs (window);
 726       }
 727       break;
 728
 729     case DWET_POSITION_SIZE:
 730       private->x = dfbevent->x;
 731       private->y = dfbevent->y;
 732       /* fallthru */
 733
 734     case DWET_SIZE:
 735       {
 736         GdkDrawableImplDirectFB *impl;
 737         GdkWindow               *event_win;
 738         GList                   *list;
 739
 740         impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
 741
 742         event_win = gdk_directfb_other_event_window (window, GDK_CONFIGURE);
 743
 744         if (event_win)
 745           {
 746             event = gdk_directfb_event_make (event_win, GDK_CONFIGURE);
 747             event->configure.x      = private->x;
 748             event->configure.y      = private->y;
 749             event->configure.width  = dfbevent->w;
 750             event->configure.height = dfbevent->h;
 751           }
 752
 753         impl->width  = dfbevent->w;
 754         impl->height = dfbevent->h;
 755
 756         for (list = private->children; list; list = list->next)
 757           {
 758             GdkWindowObject         *win;
 759             GdkDrawableImplDirectFB *impl;
 760
 761             win  = GDK_WINDOW_OBJECT (list->data);
 762             impl = GDK_DRAWABLE_IMPL_DIRECTFB (win->impl);
 763
 764             _gdk_directfb_move_resize_child (GDK_WINDOW (win),
 765                                              win->x, win->y,
 766                                              impl->width, impl->height);
 767           }
 768
 769         _gdk_directfb_calc_abs (window);
 770
 771         gdk_window_clear (window);
 772         gdk_window_invalidate_rect (window, NULL, TRUE);
 773       }
 774       break;
 775
 776     case DWET_KEYDOWN:
 777     case DWET_KEYUP:
 778       {
 779
 780         GdkEventType type = (dfbevent->type == DWET_KEYUP ?
 781                              GDK_KEY_RELEASE : GDK_KEY_PRESS);
 782         GdkWindow *event_win =
 783           gdk_directfb_keyboard_event_window (gdk_directfb_window_find_focus (),
 784                                               type);
 785         if (event_win)
 786           {
 787             event = gdk_directfb_event_make (event_win, type);
 788             gdk_directfb_translate_key_event (dfbevent, &event->key);
 789           }
 790       }
 791       break;
 792
 793     case DWET_LEAVE:
 794       _gdk_directfb_mouse_x = dfbevent->cx;
 795       _gdk_directfb_mouse_y = dfbevent->cy;
 796
 797       gdk_directfb_window_send_crossing_events (NULL, _gdk_parent_root,
 798                                                 GDK_CROSSING_NORMAL);
 799
 800       if (gdk_directfb_apply_focus_opacity)
 801         {
 802           if (GDK_WINDOW_IS_MAPPED (window))
 803             GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
 804               (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
 805                (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 1) +
 806                (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 2));
 807         }
 808       break;
 809
 810     case DWET_ENTER:
 811       {
 812         GdkWindow *child;
 813
 814         _gdk_directfb_mouse_x = dfbevent->cx;
 815         _gdk_directfb_mouse_y = dfbevent->cy;
 816
 817         child = gdk_directfb_child_at (window, &dfbevent->x, &dfbevent->y);
 818
 819         /* this makes sure pointer is set correctly when it previously left
 820          * a window being not standard shaped
 821          */
 822         gdk_window_set_cursor (window, NULL);
 823         gdk_directfb_window_send_crossing_events (NULL, child,
 824                                                   GDK_CROSSING_NORMAL);
 825
 826         if (gdk_directfb_apply_focus_opacity)
 827           {
 828             GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
 829               (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
 830                GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity);
 831           }
 832       }
 833       break;
 834
 835     case DWET_CLOSE:
 836       {
 837
 838         GdkWindow *event_win;
 839
 840         event_win = gdk_directfb_other_event_window (window, GDK_DELETE);
 841
 842         if (event_win)
 843           event = gdk_directfb_event_make (event_win, GDK_DELETE);
 844       }
 845       break;
 846
 847     case DWET_DESTROYED:
 848       {
 849         GdkWindow *event_win;
 850
 851         event_win = gdk_directfb_other_event_window (window, GDK_DESTROY);
 852
 853         if (event_win)
 854           event = gdk_directfb_event_make (event_win, GDK_DESTROY);
 855
 856         gdk_window_destroy_notify (window);
 857       }
 858       break;
 859
 860     case DWET_WHEEL:
 861       {
 862         GdkWindow *event_win;
 863
 864         _gdk_directfb_mouse_x = dfbevent->cx;
 865         _gdk_directfb_mouse_y = dfbevent->cy;
 866
 867         if (_gdk_directfb_pointer_grab_window)
 868           {
 869             GdkDrawableImplDirectFB *impl;
 870
 871             event_win = _gdk_directfb_pointer_grab_window;
 872             impl =
 873               GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (event_win)->impl);
 874
 875             dfbevent->x = dfbevent->cx - impl->abs_x;
 876             dfbevent->y = dfbevent->cy - impl->abs_y;
 877           }
 878         else
 879           {
 880             event_win = gdk_directfb_child_at (window,
 881                                                &dfbevent->x, &dfbevent->y);
 882           }
 883
 884         if (event_win)
 885           {
 886             event = gdk_directfb_event_make (event_win, GDK_SCROLL);
 887
 888             event->scroll.direction = (dfbevent->step < 0 ?
 889                                        GDK_SCROLL_DOWN : GDK_SCROLL_UP);
 890
 891             event->scroll.x_root = _gdk_directfb_mouse_x;
 892             event->scroll.y_root = _gdk_directfb_mouse_y;
 893             event->scroll.x      = dfbevent->x;
 894             event->scroll.y      = dfbevent->y;
 895             event->scroll.state  = _gdk_directfb_modifiers;
 896             event->scroll.device = display->core_pointer;
 897           }
 898       }
 899       break;
 900
 901     default:
 902       g_message ("unhandled DirectFB windowing event 0x%08x", dfbevent->type);
 903     }
 904
 905   g_object_unref (G_OBJECT (window));
 906
 907   return event;
 908 }
 909
 910 gboolean
 911 gdk_screen_get_setting (GdkScreen   *screen,
 912                         const gchar *name,
 913                         GValue      *value)
 914 {
 915   return FALSE;
 916 }
 917
 918 void
 919 gdk_display_add_client_message_filter (GdkDisplay   *display,
 920                                        GdkAtom       message_type,
 921                                        GdkFilterFunc func,
 922                                        gpointer      data)
 923 {
 924   /* XXX: display should be used */
 925   GdkClientFilter *filter = g_new (GdkClientFilter, 1);
 926
 927   filter->type = message_type;
 928   filter->function = func;
 929   filter->data = data;
 930   client_filters = g_list_append (client_filters, filter);
 931 }
 932
 933
 934 void
 935 gdk_add_client_message_filter (GdkAtom       message_type,
 936                                GdkFilterFunc func,
 937                                gpointer      data)
 938 {
 939   gdk_display_add_client_message_filter (gdk_display_get_default (),
 940                                          message_type, func, data);
 941 }
 942
 943 void
 944 gdk_screen_broadcast_client_message (GdkScreen *screen,
 945                                      GdkEvent  *sev)
 946 {
 947   GdkWindow *root_window;
 948   GdkWindowObject *private;
 949   GList *top_level = NULL;
 950
 951   g_return_if_fail (GDK_IS_SCREEN (screen));
 952   g_return_if_fail(sev != NULL);
 953
 954   root_window = gdk_screen_get_root_window (screen);
 955
 956   g_return_if_fail(GDK_IS_WINDOW(root_window));
 957
 958   private = GDK_WINDOW_OBJECT (root_window);
 959
 960   for (top_level = private->children; top_level; top_level = top_level->next)
 961     {
 962       gdk_event_send_client_message_for_display (gdk_drawable_get_display(GDK_DRAWABLE(root_window)),
 963                                                 sev,
 964                                                 (guint32)(GDK_WINDOW_DFB_ID(GDK_WINDOW(top_level->data))));
 965    }
 966 }
 967
 968
 969 /**
 970  * gdk_net_wm_supports:
 971  * @property: a property atom.
 972  *
 973  * This function is specific to the X11 backend of GDK, and indicates
 974  * whether the window manager for the default screen supports a certain
 975  * hint from the Extended Window Manager Hints Specification. See
 976  * gdk_x11_screen_supports_net_wm_hint() for complete details.
 977  *
 978  * Return value: %TRUE if the window manager supports @property
 979  **/
 980
 981
 982 gboolean
 983 gdk_net_wm_supports (GdkAtom property)
 984 {
 985    return FALSE;
 986 }
 987
 988 void
 989 _gdk_windowing_event_data_copy (const GdkEvent *src,
 990                                 GdkEvent       *dst)
 991 {
 992 }
 993
 994 void
 995 _gdk_windowing_event_data_free (GdkEvent *event)
 996 {
 997 }
 998
 999 #define __GDK_EVENTS_X11_C__
1000 #include "gdkaliasdef.c"