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