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 void
 423 gdk_directfb_event_windows_remove (GdkWindow *window)
 424 {
 425   GdkWindowImplDirectFB *impl;
 426
 427   g_return_if_fail (GDK_IS_WINDOW (window));
 428
 429   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
 430
 431   if (!impl->window)
 432     return;
 433
 434   if (EventBuffer)
 435     impl->window->DetachEventBuffer (impl->window, EventBuffer);
 436 /* FIXME: should we warn if (! EventBuffer) ? */
 437 }
 438
 439 GdkWindow *
 440 gdk_directfb_child_at (GdkWindow *window,
 441                        gint      *winx,
 442                        gint      *winy)
 443 {
 444   GdkWindowObject *private;
 445   GList           *list;
 446
 447   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 448
 449   private = GDK_WINDOW_OBJECT (window);
 450   for (list = private->children; list; list = list->next)
 451     {
 452       GdkWindowObject *win = list->data;
 453
 454       if (GDK_WINDOW_IS_MAPPED (win) &&
 455           *winx >= win->x  &&
 456           *winx <  win->x + GDK_DRAWABLE_IMPL_DIRECTFB (win->impl)->width  &&
 457           *winy >= win->y  &&
 458           *winy <  win->y + GDK_DRAWABLE_IMPL_DIRECTFB (win->impl)->height)
 459         {
 460           *winx -= win->x;
 461           *winy -= win->y;
 462
 463           return gdk_directfb_child_at (GDK_WINDOW (win), winx, winy );
 464         }
 465     }
 466
 467   return window;
 468 }
 469
 470 static GdkEvent *
 471 gdk_event_translate (DFBWindowEvent *dfbevent,
 472                      GdkWindow      *window)
 473 {
 474   GdkWindowObject *private;
 475   GdkDisplay      *display;
 476   GdkEvent        *event    = NULL;
 477
 478   g_return_val_if_fail (dfbevent != NULL, NULL);
 479   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 480
 481   private = GDK_WINDOW_OBJECT (window);
 482
 483   g_object_ref (G_OBJECT (window));
 484
 485   /*
 486    * Apply per-window filters
 487    *
 488    * If result is GDK_FILTER_CONTINUE, we continue as if nothing
 489    * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,
 490    * we return TRUE and won't dispatch the event.
 491    */
 492   if (private->filters)
 493     {
 494       switch (apply_filters (window, dfbevent, private->filters))
 495         {
 496         case GDK_FILTER_REMOVE:
 497         case GDK_FILTER_TRANSLATE:
 498           g_object_unref (G_OBJECT (window));
 499           return NULL;
 500
 501         default:
 502           break;
 503         }
 504     }
 505
 506   display = gdk_drawable_get_display (GDK_DRAWABLE (window));
 507
 508   switch (dfbevent->type)
 509     {
 510     case DWET_BUTTONDOWN:
 511     case DWET_BUTTONUP:
 512       {
 513         static gboolean  click_grab = FALSE;
 514         GdkWindow       *child;
 515         gint             wx, wy;
 516         guint            mask;
 517         guint            button;
 518
 519         _gdk_directfb_mouse_x = wx = dfbevent->cx;
 520         _gdk_directfb_mouse_y = wy = dfbevent->cy;
 521
 522         switch (dfbevent->button)
 523           {
 524           case DIBI_LEFT:
 525             button = 1;
 526             mask   = GDK_BUTTON1_MASK;
 527             break;
 528           case DIBI_MIDDLE:
 529             button = 2;
 530             mask   = GDK_BUTTON2_MASK;
 531             break;
 532           case DIBI_RIGHT:
 533             button = 3;
 534             mask   = GDK_BUTTON3_MASK;
 535             break;
 536           default:
 537             button = dfbevent->button + 1;
 538             mask   = 0;
 539             break;
 540           }
 541
 542         child = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
 543
 544         if (_gdk_directfb_pointer_grab_window &&
 545             (_gdk_directfb_pointer_grab_events & (dfbevent->type ==
 546                                                   DWET_BUTTONDOWN ?
 547                                                   GDK_BUTTON_PRESS_MASK :
 548                                                   GDK_BUTTON_RELEASE_MASK)) &&
 549             (_gdk_directfb_pointer_grab_owner_events == FALSE ||
 550              child == _gdk_parent_root) )
 551           {
 552             GdkDrawableImplDirectFB *impl;
 553
 554             child = _gdk_directfb_pointer_grab_window;
 555             impl  = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (child)->impl);
 556
 557             dfbevent->x = dfbevent->cx - impl->abs_x;
 558             dfbevent->y = dfbevent->cy - impl->abs_y;
 559           }
 560         else if (!_gdk_directfb_pointer_grab_window ||
 561                  (_gdk_directfb_pointer_grab_owner_events == TRUE))
 562           {
 563             dfbevent->x = wx;
 564             dfbevent->y = wy;
 565           }
 566         else
 567           {
 568             child = NULL;
 569           }
 570
 571         if (dfbevent->type == DWET_BUTTONDOWN)
 572           _gdk_directfb_modifiers |= mask;
 573         else
 574           _gdk_directfb_modifiers &= ~mask;
 575
 576         if (child)
 577           {
 578             event =
 579               gdk_directfb_event_make (child,
 580                                        dfbevent->type == DWET_BUTTONDOWN ?
 581                                        GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
 582
 583             event->button.x_root = _gdk_directfb_mouse_x;
 584             event->button.y_root = _gdk_directfb_mouse_y;
 585
 586             event->button.x = dfbevent->x;
 587             event->button.y = dfbevent->y;
 588
 589             event->button.state  = _gdk_directfb_modifiers;
 590             event->button.button = button;
 591             event->button.device = display->core_pointer;
 592
 593             GDK_NOTE (EVENTS,
 594                       g_message ("button: %d at %d,%d %s with state 0x%08x",
 595                                  event->button.button,
 596                                  (int)event->button.x, (int)event->button.y,
 597                                  dfbevent->type == DWET_BUTTONDOWN ?
 598                                  "pressed" : "released",
 599                                  _gdk_directfb_modifiers));
 600
 601             if (dfbevent->type == DWET_BUTTONDOWN)
 602               _gdk_event_button_generate (display, event);
 603           }
 604
 605         /* Handle implicit button grabs: */
 606         if (dfbevent->type == DWET_BUTTONDOWN  &&  !click_grab  &&  child)
 607           {
 608             if (gdk_directfb_pointer_grab (child, FALSE,
 609                                            gdk_window_get_events (child),
 610                                            NULL, NULL,
 611                                            GDK_CURRENT_TIME,
 612                                            TRUE) == GDK_GRAB_SUCCESS)
 613               click_grab = TRUE;
 614           }
 615         else if (dfbevent->type == DWET_BUTTONUP &&
 616                  !(_gdk_directfb_modifiers & (GDK_BUTTON1_MASK |
 617                                               GDK_BUTTON2_MASK |
 618                                               GDK_BUTTON3_MASK)) && click_grab)
 619           {
 620             gdk_directfb_pointer_ungrab (GDK_CURRENT_TIME, TRUE);
 621             click_grab = FALSE;
 622           }
 623       }
 624       break;
 625
 626     case DWET_MOTION:
 627       {
 628         GdkWindow *event_win=NULL;
 629         GdkWindow *child;
 630
 631         _gdk_directfb_mouse_x = dfbevent->cx;
 632         _gdk_directfb_mouse_y = dfbevent->cy;
 633
 634         //child = gdk_directfb_child_at (window, &dfbevent->x, &dfbevent->y);
 635     /* Go all the way to root to catch popup menus */
 636     int wx=_gdk_directfb_mouse_x;
 637     int wy=_gdk_directfb_mouse_y;
 638         child = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
 639
 640     /* first let's see if any cossing event has to be send */
 641     gdk_directfb_window_send_crossing_events (NULL, child, GDK_CROSSING_NORMAL);
 642
 643     /* then dispatch the motion event to the window the cursor it's inside */
 644         event_win = gdk_directfb_pointer_event_window (child, GDK_MOTION_NOTIFY);
 645
 646
 647         if (event_win)
 648           {
 649
 650             if (event_win == _gdk_directfb_pointer_grab_window) {
 651                 GdkDrawableImplDirectFB *impl;
 652
 653                 child = _gdk_directfb_pointer_grab_window;
 654                 impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (child)->impl);
 655
 656                 dfbevent->x = _gdk_directfb_mouse_x - impl->abs_x;
 657                 dfbevent->y = _gdk_directfb_mouse_y - impl->abs_y;
 658               }
 659
 660             event = gdk_directfb_event_make (child, GDK_MOTION_NOTIFY);
 661
 662             event->motion.x_root = _gdk_directfb_mouse_x;
 663             event->motion.y_root = _gdk_directfb_mouse_y;
 664
 665             //event->motion.x = dfbevent->x;
 666             //event->motion.y = dfbevent->y;
 667             event->motion.x = wx;
 668             event->motion.y = wy;
 669
 670             event->motion.state   = _gdk_directfb_modifiers;
 671             event->motion.is_hint = FALSE;
 672             event->motion.device  = display->core_pointer;
 673
 674             if (GDK_WINDOW_OBJECT (event_win)->event_mask &
 675                 GDK_POINTER_MOTION_HINT_MASK)
 676               {
 677                 while (EventBuffer->PeekEvent (EventBuffer,
 678                                                DFB_EVENT (dfbevent)) == DFB_OK
 679                        && dfbevent->type == DWET_MOTION)
 680                   {
 681                     EventBuffer->GetEvent (EventBuffer, DFB_EVENT (dfbevent));
 682                     event->motion.is_hint = TRUE;
 683                   }
 684               }
 685           }
 686           /* make sure crossing events go to the event window found */
 687 /*        GdkWindow *ev_win = ( event_win == NULL ) ? gdk_window_at_pointer (NULL,NULL) :event_win;
 688              gdk_directfb_window_send_crossing_events (NULL,ev_win,GDK_CROSSING_NORMAL);
 689 */
 690       }
 691       break;
 692
 693     case DWET_GOTFOCUS:
 694       gdk_directfb_change_focus (window);
 695
 696       break;
 697
 698     case DWET_LOSTFOCUS:
 699       gdk_directfb_change_focus (_gdk_parent_root);
 700
 701       break;
 702
 703     case DWET_POSITION:
 704       {
 705         GdkWindow *event_win;
 706
 707         private->x = dfbevent->x;
 708         private->y = dfbevent->y;
 709
 710         event_win = gdk_directfb_other_event_window (window, GDK_CONFIGURE);
 711
 712         if (event_win)
 713           {
 714             event = gdk_directfb_event_make (event_win, GDK_CONFIGURE);
 715             event->configure.x = dfbevent->x;
 716             event->configure.y = dfbevent->y;
 717             event->configure.width =
 718               GDK_DRAWABLE_IMPL_DIRECTFB (private->impl)->width;
 719             event->configure.height =
 720               GDK_DRAWABLE_IMPL_DIRECTFB (private->impl)->height;
 721           }
 722
 723         _gdk_directfb_calc_abs (window);
 724       }
 725       break;
 726
 727     case DWET_POSITION_SIZE:
 728       private->x = dfbevent->x;
 729       private->y = dfbevent->y;
 730       /* fallthru */
 731
 732     case DWET_SIZE:
 733       {
 734         GdkDrawableImplDirectFB *impl;
 735         GdkWindow               *event_win;
 736         GList                   *list;
 737
 738         impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
 739
 740         event_win = gdk_directfb_other_event_window (window, GDK_CONFIGURE);
 741
 742         if (event_win)
 743           {
 744             event = gdk_directfb_event_make (event_win, GDK_CONFIGURE);
 745             event->configure.x      = private->x;
 746             event->configure.y      = private->y;
 747             event->configure.width  = dfbevent->w;
 748             event->configure.height = dfbevent->h;
 749           }
 750
 751         impl->width  = dfbevent->w;
 752         impl->height = dfbevent->h;
 753
 754         for (list = private->children; list; list = list->next)
 755           {
 756             GdkWindowObject         *win;
 757             GdkDrawableImplDirectFB *impl;
 758
 759             win  = GDK_WINDOW_OBJECT (list->data);
 760             impl = GDK_DRAWABLE_IMPL_DIRECTFB (win->impl);
 761
 762             _gdk_directfb_move_resize_child (GDK_WINDOW (win),
 763                                              win->x, win->y,
 764                                              impl->width, impl->height);
 765           }
 766
 767         _gdk_directfb_calc_abs (window);
 768
 769         gdk_window_clear (window);
 770         gdk_window_invalidate_rect (window, NULL, TRUE);
 771       }
 772       break;
 773
 774     case DWET_KEYDOWN:
 775     case DWET_KEYUP:
 776       {
 777
 778         GdkEventType type = (dfbevent->type == DWET_KEYUP ?
 779                              GDK_KEY_RELEASE : GDK_KEY_PRESS);
 780         GdkWindow *event_win =
 781           gdk_directfb_keyboard_event_window (gdk_directfb_window_find_focus (),
 782                                               type);
 783         if (event_win)
 784           {
 785             event = gdk_directfb_event_make (event_win, type);
 786             gdk_directfb_translate_key_event (dfbevent, &event->key);
 787           }
 788       }
 789       break;
 790
 791     case DWET_LEAVE:
 792       _gdk_directfb_mouse_x = dfbevent->cx;
 793       _gdk_directfb_mouse_y = dfbevent->cy;
 794
 795       gdk_directfb_window_send_crossing_events (NULL, _gdk_parent_root,
 796                                                 GDK_CROSSING_NORMAL);
 797
 798       if (gdk_directfb_apply_focus_opacity)
 799         {
 800           if (GDK_WINDOW_IS_MAPPED (window))
 801             GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
 802               (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
 803                (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 1) +
 804                (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 2));
 805         }
 806       break;
 807
 808     case DWET_ENTER:
 809       {
 810         GdkWindow *child;
 811
 812         _gdk_directfb_mouse_x = dfbevent->cx;
 813         _gdk_directfb_mouse_y = dfbevent->cy;
 814
 815         child = gdk_directfb_child_at (window, &dfbevent->x, &dfbevent->y);
 816
 817         /* this makes sure pointer is set correctly when it previously left
 818          * a window being not standard shaped
 819          */
 820         gdk_window_set_cursor (window, NULL);
 821         gdk_directfb_window_send_crossing_events (NULL, child,
 822                                                   GDK_CROSSING_NORMAL);
 823
 824         if (gdk_directfb_apply_focus_opacity)
 825           {
 826             GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
 827               (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
 828                GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity);
 829           }
 830       }
 831       break;
 832
 833     case DWET_CLOSE:
 834       {
 835
 836         GdkWindow *event_win;
 837
 838         event_win = gdk_directfb_other_event_window (window, GDK_DELETE);
 839
 840         if (event_win)
 841           event = gdk_directfb_event_make (event_win, GDK_DELETE);
 842       }
 843       break;
 844
 845     case DWET_DESTROYED:
 846       {
 847         GdkWindow *event_win;
 848
 849         event_win = gdk_directfb_other_event_window (window, GDK_DESTROY);
 850
 851         if (event_win)
 852           event = gdk_directfb_event_make (event_win, GDK_DESTROY);
 853
 854         gdk_window_destroy_notify (window);
 855       }
 856       break;
 857
 858     case DWET_WHEEL:
 859       {
 860         GdkWindow *event_win;
 861
 862         _gdk_directfb_mouse_x = dfbevent->cx;
 863         _gdk_directfb_mouse_y = dfbevent->cy;
 864
 865         if (_gdk_directfb_pointer_grab_window)
 866           {
 867             GdkDrawableImplDirectFB *impl;
 868
 869             event_win = _gdk_directfb_pointer_grab_window;
 870             impl =
 871               GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (event_win)->impl);
 872
 873             dfbevent->x = dfbevent->cx - impl->abs_x;
 874             dfbevent->y = dfbevent->cy - impl->abs_y;
 875           }
 876         else
 877           {
 878             event_win = gdk_directfb_child_at (window,
 879                                                &dfbevent->x, &dfbevent->y);
 880           }
 881
 882         if (event_win)
 883           {
 884             event = gdk_directfb_event_make (event_win, GDK_SCROLL);
 885
 886             event->scroll.direction = (dfbevent->step < 0 ?
 887                                        GDK_SCROLL_DOWN : GDK_SCROLL_UP);
 888
 889             event->scroll.x_root = _gdk_directfb_mouse_x;
 890             event->scroll.y_root = _gdk_directfb_mouse_y;
 891             event->scroll.x      = dfbevent->x;
 892             event->scroll.y      = dfbevent->y;
 893             event->scroll.state  = _gdk_directfb_modifiers;
 894             event->scroll.device = display->core_pointer;
 895           }
 896       }
 897       break;
 898
 899     default:
 900       g_message ("unhandled DirectFB windowing event 0x%08x", dfbevent->type);
 901     }
 902
 903   g_object_unref (G_OBJECT (window));
 904
 905   return event;
 906 }
 907
 908 gboolean
 909 gdk_screen_get_setting (GdkScreen   *screen,
 910                         const gchar *name,
 911                         GValue      *value)
 912 {
 913   return FALSE;
 914 }
 915
 916 void
 917 gdk_display_add_client_message_filter (GdkDisplay   *display,
 918                                        GdkAtom       message_type,
 919                                        GdkFilterFunc func,
 920                                        gpointer      data)
 921 {
 922   /* XXX: display should be used */
 923   GdkClientFilter *filter = g_new (GdkClientFilter, 1);
 924
 925   filter->type = message_type;
 926   filter->function = func;
 927   filter->data = data;
 928   client_filters = g_list_append (client_filters, filter);
 929 }
 930
 931
 932 void
 933 gdk_add_client_message_filter (GdkAtom       message_type,
 934                                GdkFilterFunc func,
 935                                gpointer      data)
 936 {
 937   gdk_display_add_client_message_filter (gdk_display_get_default (),
 938                                          message_type, func, data);
 939 }
 940
 941 void
 942 gdk_screen_broadcast_client_message (GdkScreen *screen,
 943                                      GdkEvent  *sev)
 944 {
 945   GdkWindow *root_window;
 946   GdkWindowObject *private;
 947   GList *top_level = NULL;
 948
 949   g_return_if_fail (GDK_IS_SCREEN (screen));
 950   g_return_if_fail(sev != NULL);
 951
 952   root_window = gdk_screen_get_root_window (screen);
 953
 954   g_return_if_fail(GDK_IS_WINDOW(root_window));
 955
 956   private = GDK_WINDOW_OBJECT (root_window);
 957
 958   for (top_level = private->children; top_level; top_level = top_level->next)
 959     {
 960       gdk_event_send_client_message_for_display (gdk_drawable_get_display(GDK_DRAWABLE(root_window)),
 961                                                 sev,
 962                                                 (guint32)(GDK_WINDOW_DFB_ID(GDK_WINDOW(top_level->data))));
 963    }
 964 }
 965
 966
 967 /**
 968  * gdk_net_wm_supports:
 969  * @property: a property atom.
 970  *
 971  * This function is specific to the X11 backend of GDK, and indicates
 972  * whether the window manager for the default screen supports a certain
 973  * hint from the Extended Window Manager Hints Specification. See
 974  * gdk_x11_screen_supports_net_wm_hint() for complete details.
 975  *
 976  * Return value: %TRUE if the window manager supports @property
 977  **/
 978
 979
 980 gboolean
 981 gdk_net_wm_supports (GdkAtom property)
 982 {
 983    return FALSE;
 984 }
 985
 986 void
 987 _gdk_windowing_event_data_copy (const GdkEvent *src,
 988                                 GdkEvent       *dst)
 989 {
 990 }
 991
 992 void
 993 _gdk_windowing_event_data_free (GdkEvent *event)
 994 {
 995 }
 996
 997 #define __GDK_EVENTS_X11_C__
 998 #include "gdkaliasdef.c"