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

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * Copyright (C) 1998-1999 Tor Lillqvist
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.
  24  */
  25
  26 /*
  27  * GTK+ DirectFB backend
  28  * Copyright (C) 2001-2002  convergence integrated media GmbH
  29  * Copyright (C) 2002-2004  convergence GmbH
  30  * Written by Denis Oliver Kropp <dok@convergence.de> and
  31  *            Sven Neumann <sven@convergence.de>
  32  */
  33
  34 #include <config.h>
  35 #include "gdk.h"
  36 #include "gdkwindow.h"
  37
  38 #include "gdkdirectfb.h"
  39 #include "gdkprivate-directfb.h"
  40 #include "gdkdisplay-directfb.h"
  41
  42 #include "gdkregion-generic.h"
  43
  44 #include "gdkinternals.h"
  45 #include "gdkalias.h"
  46 #include "cairo.h"
  47 #include <assert.h>
  48
  49 static GdkRegion * gdk_window_impl_directfb_get_visible_region (GdkDrawable *drawable);
  50 static void        gdk_window_impl_directfb_set_colormap       (GdkDrawable *drawable,
  51                                                                 GdkColormap *colormap);
  52 static void gdk_window_impl_directfb_init       (GdkWindowImplDirectFB      *window);
  53 static void gdk_window_impl_directfb_class_init (GdkWindowImplDirectFBClass *klass);
  54 static void gdk_window_impl_directfb_finalize   (GObject                    *object);
  55
  56 typedef struct
  57 {
  58   GdkWindowChildChanged  changed;
  59   GdkWindowChildGetPos   get_pos;
  60   gpointer               user_data;
  61 } GdkWindowChildHandlerData;
  62
  63
  64 /* Code for dirty-region queueing
  65  */
  66 static GSList *update_windows = NULL;
  67 static guint update_idle = 0;
  68
  69 static void
  70 gdk_window_directfb_process_all_updates (void)
  71 {
  72   GSList *old_update_windows = update_windows;
  73   GSList *tmp_list = update_windows;
  74
  75   if (update_idle)
  76     g_source_remove (update_idle);
  77
  78   update_windows = NULL;
  79   update_idle = 0;
  80
  81   g_slist_foreach (old_update_windows, (GFunc)g_object_ref, NULL);
  82
  83   while (tmp_list)
  84     {
  85       GdkWindowObject *private = (GdkWindowObject *)tmp_list->data;
  86
  87       if (private->update_freeze_count)
  88         update_windows = g_slist_prepend (update_windows, private);
  89       else
  90         gdk_window_process_updates(tmp_list->data,TRUE);
  91
  92       g_object_unref (tmp_list->data);
  93       tmp_list = tmp_list->next;
  94     }
  95
  96   g_slist_free (old_update_windows);
  97
  98 }
  99
 100 static gboolean
 101 gdk_window_update_idle (gpointer data)
 102 {
 103   GDK_THREADS_ENTER ();
 104   gdk_window_directfb_process_all_updates ();
 105   GDK_THREADS_LEAVE ();
 106
 107   return FALSE;
 108 }
 109
 110 static void
 111 gdk_window_schedule_update (GdkWindow *window)
 112 {
 113   if (window && GDK_WINDOW_OBJECT (window)->update_freeze_count)
 114     return;
 115
 116   if (!update_idle)
 117     {
 118       update_idle = g_idle_add_full (GDK_PRIORITY_REDRAW,
 119                                      gdk_window_update_idle, NULL, NULL);
 120     }
 121 }
 122
 123
 124 static GdkWindow *gdk_directfb_window_containing_pointer = NULL;
 125 static GdkWindow *gdk_directfb_focused_window            = NULL;
 126 static gpointer   parent_class                           = NULL;
 127 GdkWindow * _gdk_parent_root = NULL;
 128 static void
 129 gdk_window_impl_directfb_paintable_init (GdkPaintableIface *iface);
 130
 131
 132
 133
 134
 135 GType
 136 gdk_window_impl_directfb_get_type (void)
 137 {
 138   static GType object_type = 0;
 139
 140   if (!object_type)
 141     {
 142       static const GTypeInfo object_info =
 143         {
 144           sizeof (GdkWindowImplDirectFBClass),
 145           (GBaseInitFunc) NULL,
 146           (GBaseFinalizeFunc) NULL,
 147           (GClassInitFunc) gdk_window_impl_directfb_class_init,
 148           NULL,           /* class_finalize */
 149           NULL,           /* class_data */
 150           sizeof (GdkWindowImplDirectFB),
 151           0,              /* n_preallocs */
 152           (GInstanceInitFunc) gdk_window_impl_directfb_init,
 153         };
 154
 155     static const GInterfaceInfo paintable_info =
 156       {
 157     (GInterfaceInitFunc) gdk_window_impl_directfb_paintable_init,
 158     NULL,
 159     NULL
 160       };
 161
 162       object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_DIRECTFB,
 163                                             "GdkWindowImplDirectFB",
 164                                             &object_info, 0);
 165        g_type_add_interface_static (object_type,
 166                    GDK_TYPE_PAINTABLE,
 167                    &paintable_info);
 168
 169     }
 170
 171   return object_type;
 172 }
 173
 174 GType
 175 _gdk_window_impl_get_type (void)
 176 {
 177   return gdk_window_impl_directfb_get_type ();
 178 }
 179
 180 static void
 181 gdk_window_impl_directfb_init (GdkWindowImplDirectFB *impl)
 182 {
 183   impl->drawable.width  = 1;
 184   impl->drawable.height = 1;
 185   //cannot use gdk_cursor_new here since gdk_display_get_default
 186   //does not work yet.
 187   impl->cursor          = gdk_cursor_new_for_display (GDK_DISPLAY_OBJECT(_gdk_display),GDK_LEFT_PTR);
 188   impl->opacity         = 255;
 189 }
 190
 191 static void
 192 gdk_window_impl_directfb_class_init (GdkWindowImplDirectFBClass *klass)
 193 {
 194   GObjectClass     *object_class   = G_OBJECT_CLASS (klass);
 195   GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
 196
 197   parent_class = g_type_class_peek_parent (klass);
 198
 199   object_class->finalize = gdk_window_impl_directfb_finalize;
 200
 201   drawable_class->set_colormap = gdk_window_impl_directfb_set_colormap;
 202
 203   /* Visible and clip regions are the same */
 204
 205   drawable_class->get_clip_region =
 206     gdk_window_impl_directfb_get_visible_region;
 207
 208   drawable_class->get_visible_region =
 209     gdk_window_impl_directfb_get_visible_region;
 210 }
 211
 212 static void
 213 g_free_2nd (gpointer a,
 214             gpointer b,
 215             gpointer data)
 216 {
 217   g_free (b);
 218 }
 219
 220 static void
 221 gdk_window_impl_directfb_finalize (GObject *object)
 222 {
 223   GdkWindowImplDirectFB *impl = GDK_WINDOW_IMPL_DIRECTFB (object);
 224
 225   if (GDK_WINDOW_IS_MAPPED (impl->drawable.wrapper))
 226     gdk_window_hide (impl->drawable.wrapper);
 227
 228   if (impl->cursor)
 229     gdk_cursor_unref (impl->cursor);
 230
 231   if (impl->properties)
 232     {
 233       g_hash_table_foreach (impl->properties, g_free_2nd, NULL);
 234       g_hash_table_destroy (impl->properties);
 235     }
 236   if (impl->window)
 237     {
 238       gdk_directfb_window_id_table_remove (impl->dfb_id);
 239           /* native window resource must be release before we can finalize !*/
 240       impl->window = NULL;
 241     }
 242
 243   if (G_OBJECT_CLASS (parent_class)->finalize)
 244     G_OBJECT_CLASS (parent_class)->finalize (object);
 245 }
 246
 247 static GdkRegion*
 248 gdk_window_impl_directfb_get_visible_region (GdkDrawable *drawable)
 249 {
 250   GdkDrawableImplDirectFB *priv = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
 251   GdkRectangle             rect = { 0, 0, 0, 0 };
 252   DFBRectangle             drect = { 0, 0, 0, 0 };
 253
 254   if (priv->surface)
 255   priv->surface->GetVisibleRectangle (priv->surface, &drect);
 256   rect.x= drect.x;
 257   rect.y= drect.y;
 258   rect.width=drect.w;
 259   rect.height=drect.h;
 260   return gdk_region_rectangle (&rect);
 261 }
 262
 263 static void
 264 gdk_window_impl_directfb_set_colormap (GdkDrawable *drawable,
 265                                        GdkColormap *colormap)
 266 {
 267   GDK_DRAWABLE_CLASS (parent_class)->set_colormap (drawable, colormap);
 268
 269   if (colormap)
 270     {
 271        GdkDrawableImplDirectFB *priv = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
 272
 273        if (priv->surface)
 274          {
 275            IDirectFBPalette *palette = gdk_directfb_colormap_get_palette (colormap);
 276
 277            if (palette)
 278              priv->surface->SetPalette (priv->surface, palette);
 279          }
 280     }
 281 }
 282
 283
 284 static gboolean
 285 create_directfb_window (GdkWindowImplDirectFB *impl,
 286                         DFBWindowDescription  *desc,
 287                         DFBWindowOptions       window_options)
 288 {
 289   DFBResult        ret;
 290   IDirectFBWindow *window;
 291
 292   ret = _gdk_display->layer->CreateWindow (_gdk_display->layer, desc, &window);
 293
 294   if (ret != DFB_OK)
 295     {
 296       DirectFBError ("gdk_window_new: Layer->CreateWindow failed", ret);
 297       g_assert (0);
 298       return FALSE;
 299     }
 300
 301   if ((desc->flags & DWDESC_CAPS) && (desc->caps & DWCAPS_INPUTONLY))
 302   {
 303     impl->drawable.surface = NULL;
 304   } else
 305     window->GetSurface (window, &impl->drawable.surface);
 306
 307   if (window_options)
 308     {
 309       DFBWindowOptions options;
 310       window->GetOptions (window, &options);
 311       window->SetOptions (window,  options | window_options);
 312     }
 313
 314   impl->window = window;
 315
 316   return TRUE;
 317 }
 318
 319 void
 320 _gdk_windowing_window_init (void)
 321 {
 322   GdkWindowObject       *private;
 323   GdkWindowImplDirectFB *impl;
 324   DFBDisplayLayerConfig  dlc;
 325
 326   g_assert (_gdk_parent_root == NULL);
 327
 328   _gdk_display->layer->GetConfiguration(
 329         _gdk_display->layer, &dlc );
 330
 331   _gdk_parent_root = g_object_new (GDK_TYPE_WINDOW, NULL);
 332   private = GDK_WINDOW_OBJECT (_gdk_parent_root);
 333   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
 334
 335   private->window_type = GDK_WINDOW_ROOT;
 336   private->state       = 0;
 337   private->children    = NULL;
 338   impl->drawable.paint_region   = NULL;
 339   impl->gdkWindow      = _gdk_parent_root;
 340   impl->window           = NULL;
 341   impl->drawable.abs_x   = 0;
 342   impl->drawable.abs_y   = 0;
 343   impl->drawable.width   = dlc.width;
 344   impl->drawable.height  = dlc.height;
 345   impl->drawable.wrapper = GDK_DRAWABLE (private);
 346   /* custom root window init */
 347   {
 348     DFBWindowDescription   desc;
 349     desc.flags = 0;
 350         /*XXX I must do this now its a bug  ALPHA ROOT*/
 351
 352     desc.flags = DWDESC_CAPS;
 353     desc.caps = 0;
 354     desc.caps  |= DWCAPS_NODECORATION;
 355     desc.caps  |= DWCAPS_ALPHACHANNEL;
 356     desc.flags |= ( DWDESC_WIDTH | DWDESC_HEIGHT |
 357                       DWDESC_POSX  | DWDESC_POSY );
 358     desc.posx   = 0;
 359     desc.posy   = 0;
 360     desc.width  = dlc.width;
 361     desc.height = dlc.height;
 362     create_directfb_window (impl,&desc,0);
 363         g_assert(impl->window != NULL);
 364     g_assert(impl->drawable.surface != NULL );
 365   }
 366   impl->drawable.surface->GetPixelFormat(impl->drawable.surface,&impl->drawable.format);
 367   private->depth = DFB_BITS_PER_PIXEL(impl->drawable.format);
 368   /*
 369         Now we can set up the system colormap
 370   */
 371   gdk_drawable_set_colormap (GDK_DRAWABLE (_gdk_parent_root),gdk_colormap_get_system());
 372 }
 373
 374
 375
 376 GdkWindow *
 377 gdk_directfb_window_new (GdkWindow              *parent,
 378                          GdkWindowAttr          *attributes,
 379                          gint                    attributes_mask,
 380                          DFBWindowCapabilities   window_caps,
 381                          DFBWindowOptions        window_options,
 382                          DFBSurfaceCapabilities  surface_caps)
 383 {
 384   GdkWindow             *window;
 385   GdkWindowObject       *private;
 386   GdkWindowObject       *parent_private;
 387   GdkWindowImplDirectFB *impl;
 388   GdkWindowImplDirectFB *parent_impl;
 389   GdkVisual             *visual;
 390   DFBWindowDescription   desc;
 391   gint x, y;
 392
 393   g_return_val_if_fail (attributes != NULL, NULL);
 394
 395   if (!parent || attributes->window_type != GDK_WINDOW_CHILD)
 396     parent = _gdk_parent_root;
 397
 398   window = g_object_new (GDK_TYPE_WINDOW, NULL);
 399   private = GDK_WINDOW_OBJECT (window);
 400
 401   parent_private = GDK_WINDOW_OBJECT (parent);
 402   parent_impl = GDK_WINDOW_IMPL_DIRECTFB (parent_private->impl);
 403   private->parent = parent_private;
 404
 405   x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
 406   y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
 407
 408   gdk_window_set_events (window, attributes->event_mask | GDK_STRUCTURE_MASK);
 409
 410   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
 411   impl->drawable.wrapper = GDK_DRAWABLE (window);
 412   impl->gdkWindow      = window;
 413
 414   private->x = x;
 415   private->y = y;
 416
 417   _gdk_directfb_calc_abs (window);
 418
 419   impl->drawable.width  = MAX (1, attributes->width);
 420   impl->drawable.height = MAX (1, attributes->height);
 421
 422   private->window_type = attributes->window_type;
 423
 424   desc.flags = 0;
 425
 426   if (attributes_mask & GDK_WA_VISUAL)
 427     visual = attributes->visual;
 428   else
 429     visual = gdk_drawable_get_visual (parent);
 430
 431   switch (attributes->wclass)
 432     {
 433     case GDK_INPUT_OUTPUT:
 434       private->input_only = FALSE;
 435
 436       desc.flags |= DWDESC_PIXELFORMAT;
 437       desc.pixelformat = ((GdkVisualDirectFB *) visual)->format;
 438
 439       if (DFB_PIXELFORMAT_HAS_ALPHA (desc.pixelformat))
 440         {
 441           desc.flags |= DWDESC_CAPS;
 442           desc.caps = DWCAPS_ALPHACHANNEL;
 443         }
 444       break;
 445
 446     case GDK_INPUT_ONLY:
 447       private->input_only = TRUE;
 448       desc.flags |= DWDESC_CAPS;
 449       desc.caps = DWCAPS_INPUTONLY;
 450       break;
 451
 452     default:
 453       g_warning ("gdk_window_new: unsupported window class\n");
 454       _gdk_window_destroy (window, FALSE);
 455       return NULL;
 456     }
 457
 458   switch (private->window_type)
 459     {
 460     case GDK_WINDOW_TOPLEVEL:
 461     case GDK_WINDOW_DIALOG:
 462     case GDK_WINDOW_TEMP:
 463       desc.flags |= ( DWDESC_WIDTH | DWDESC_HEIGHT |
 464                       DWDESC_POSX  | DWDESC_POSY );
 465       desc.posx   = x;
 466       desc.posy   = y;
 467       desc.width  = impl->drawable.width;
 468       desc.height = impl->drawable.height;
 469 #if 0
 470       if (window_caps)
 471         {
 472           if (! (desc.flags & DWDESC_CAPS))
 473             {
 474               desc.flags |= DWDESC_CAPS;
 475               desc.caps   = DWCAPS_NONE;
 476             }
 477
 478           desc.caps |= window_caps;
 479         }
 480
 481       if (surface_caps)
 482         {
 483           desc.flags |= DWDESC_SURFACE_CAPS;
 484           desc.surface_caps = surface_caps;
 485         }
 486 #endif
 487
 488       if (!create_directfb_window (impl, &desc, window_options))
 489         {
 490                   g_assert(0);
 491           _gdk_window_destroy (window, FALSE);
 492           return NULL;
 493         }
 494         if( desc.caps != DWCAPS_INPUTONLY )
 495                         impl->window->SetOpacity(impl->window, 0x00 );
 496       break;
 497
 498     case GDK_WINDOW_CHILD:
 499            impl->window=NULL;
 500       if (!private->input_only && parent_impl->drawable.surface)
 501         {
 502
 503           DFBRectangle rect =
 504           { x, y, impl->drawable.width, impl->drawable.height };
 505           parent_impl->drawable.surface->GetSubSurface (parent_impl->drawable.surface,
 506                                                         &rect,
 507                                                         &impl->drawable.surface);
 508         }
 509       break;
 510
 511     default:
 512       g_warning ("gdk_window_new: unsupported window type: %d",
 513                  private->window_type);
 514       _gdk_window_destroy (window, FALSE);
 515       return NULL;
 516     }
 517
 518   if (impl->drawable.surface)
 519     {
 520       GdkColormap *colormap;
 521
 522       impl->drawable.surface->GetPixelFormat (impl->drawable.surface,
 523                                               &impl->drawable.format);
 524
 525           private->depth = DFB_BITS_PER_PIXEL(impl->drawable.format);
 526
 527       if ((attributes_mask & GDK_WA_COLORMAP) && attributes->colormap)
 528         {
 529           colormap = attributes->colormap;
 530         }
 531       else
 532         {
 533           if (gdk_visual_get_system () == visual)
 534             colormap = gdk_colormap_get_system ();
 535           else
 536             colormap =gdk_drawable_get_colormap (parent);
 537         }
 538
 539       gdk_drawable_set_colormap (GDK_DRAWABLE (window), colormap);
 540     }
 541   else
 542     {
 543       impl->drawable.format = ((GdkVisualDirectFB *)visual)->format;
 544           private->depth = visual->depth;
 545     }
 546
 547   gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
 548                                   (attributes->cursor) : NULL));
 549
 550   if (parent_private)
 551     parent_private->children = g_list_prepend (parent_private->children,
 552                                                window);
 553
 554   /* we hold a reference count on ourselves */
 555   g_object_ref (window);
 556
 557   if (impl->window)
 558     {
 559       impl->window->GetID (impl->window, &impl->dfb_id);
 560       gdk_directfb_window_id_table_insert (impl->dfb_id, window);
 561       gdk_directfb_event_windows_add (window);
 562     }
 563
 564   return window;
 565 }
 566
 567 GdkWindow *
 568 gdk_window_new (GdkWindow     *parent,
 569                 GdkWindowAttr *attributes,
 570                 gint           attributes_mask)
 571 {
 572   g_return_val_if_fail (attributes != NULL, NULL);
 573
 574   return gdk_directfb_window_new (parent, attributes, attributes_mask,
 575                                   DWCAPS_NONE, DWOP_NONE, DSCAPS_NONE);
 576 }
 577 void
 578 _gdk_windowing_window_destroy_foreign (GdkWindow *window)
 579 {
 580   /* It's somebody else's window, but in our heirarchy,
 581    * so reparent it to the root window, and then send
 582    * it a delete event, as if we were a WM
 583    */
 584         _gdk_windowing_window_destroy (window,TRUE,TRUE);
 585 }
 586
 587
 588 void
 589 _gdk_windowing_window_destroy (GdkWindow *window,
 590                                gboolean   recursing,
 591                                gboolean   foreign_destroy)
 592 {
 593   GdkWindowObject       *private;
 594   GdkWindowImplDirectFB *impl;
 595
 596   g_return_if_fail (GDK_IS_WINDOW (window));
 597
 598   private = GDK_WINDOW_OBJECT (window);
 599   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
 600
 601   _gdk_selection_window_destroyed (window);
 602
 603   if (window == _gdk_directfb_pointer_grab_window)
 604     gdk_pointer_ungrab (GDK_CURRENT_TIME);
 605   if (window == _gdk_directfb_keyboard_grab_window)
 606     gdk_keyboard_ungrab (GDK_CURRENT_TIME);
 607
 608   if (window == gdk_directfb_focused_window)
 609     gdk_directfb_change_focus (NULL);
 610
 611   if (!recursing && !foreign_destroy && impl->window ) {
 612         impl->window->SetOpacity (impl->window,0);
 613                 impl->window->Close(impl->window);
 614         impl->window->Release(impl->window);
 615   }
 616
 617 #if 0 /* let the finalizer kill it */
 618   if (!recursing && !foreign_destroy)
 619     {
 620                 if (impl->window)
 621                 impl->window->Destroy (impl->window);
 622                 impl->window = NULL;
 623         }
 624 #endif
 625 }
 626
 627 /* This function is called when the window is really gone.
 628  */
 629 void
 630 gdk_window_destroy_notify (GdkWindow *window)
 631 {
 632   g_return_if_fail (GDK_IS_WINDOW (window));
 633
 634   if (!GDK_WINDOW_DESTROYED (window))
 635     {
 636       if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
 637         g_warning ("GdkWindow %p unexpectedly destroyed", window);
 638
 639       _gdk_window_destroy (window, TRUE);
 640     }
 641    g_object_unref (window);
 642 }
 643
 644 /* Focus follows pointer */
 645 GdkWindow *
 646 gdk_directfb_window_find_toplevel (GdkWindow *window)
 647 {
 648   while (window && window != _gdk_parent_root)
 649     {
 650       GdkWindow *parent = (GdkWindow *) (GDK_WINDOW_OBJECT (window))->parent;
 651
 652       if ((parent == _gdk_parent_root) && GDK_WINDOW_IS_MAPPED (window))
 653         return window;
 654
 655       window = parent;
 656     }
 657
 658   return _gdk_parent_root;
 659 }
 660
 661 GdkWindow *
 662 gdk_directfb_window_find_focus (void)
 663 {
 664   if (_gdk_directfb_keyboard_grab_window)
 665     return _gdk_directfb_keyboard_grab_window;
 666
 667   if (!gdk_directfb_focused_window)
 668     gdk_directfb_focused_window = g_object_ref (_gdk_parent_root);
 669
 670   return gdk_directfb_focused_window;
 671 }
 672
 673 void
 674 gdk_directfb_change_focus (GdkWindow *new_focus_window)
 675 {
 676   GdkEventFocus *event;
 677   GdkWindow     *old_win;
 678   GdkWindow     *new_win;
 679   GdkWindow     *event_win;
 680
 681
 682   /* No focus changes while the pointer is grabbed */
 683   if (_gdk_directfb_pointer_grab_window)
 684     return;
 685
 686   old_win = gdk_directfb_focused_window;
 687   new_win = gdk_directfb_window_find_toplevel (new_focus_window);
 688
 689   if (old_win == new_win)
 690     return;
 691
 692   if (old_win)
 693     {
 694       event_win = gdk_directfb_keyboard_event_window (old_win,
 695                                                       GDK_FOCUS_CHANGE);
 696       if (event_win)
 697         {
 698           event = (GdkEventFocus *) gdk_directfb_event_make (event_win,
 699                                                              GDK_FOCUS_CHANGE);
 700           event->in = FALSE;
 701         }
 702     }
 703
 704   event_win = gdk_directfb_keyboard_event_window (new_win,
 705                                                   GDK_FOCUS_CHANGE);
 706   if (event_win)
 707     {
 708       event = (GdkEventFocus *) gdk_directfb_event_make (event_win,
 709                                                          GDK_FOCUS_CHANGE);
 710       event->in = TRUE;
 711     }
 712
 713   if (gdk_directfb_focused_window)
 714     g_object_unref (gdk_directfb_focused_window);
 715   gdk_directfb_focused_window = g_object_ref (new_win);
 716 }
 717
 718 void
 719 gdk_window_set_accept_focus (GdkWindow *window,
 720                              gboolean accept_focus)
 721 {
 722   GdkWindowObject *private;
 723   g_return_if_fail (window != NULL);
 724   g_return_if_fail (GDK_IS_WINDOW (window));
 725
 726   private = (GdkWindowObject *)window;
 727
 728   accept_focus = accept_focus != FALSE;
 729
 730   if (private->accept_focus != accept_focus)
 731     private->accept_focus = accept_focus;
 732
 733 }
 734
 735 void
 736 gdk_window_set_focus_on_map (GdkWindow *window,
 737                              gboolean focus_on_map)
 738 {
 739   GdkWindowObject *private;
 740   g_return_if_fail (window != NULL);
 741   g_return_if_fail (GDK_IS_WINDOW (window));
 742
 743   private = (GdkWindowObject *)window;
 744
 745   focus_on_map = focus_on_map != FALSE;
 746
 747   if (private->focus_on_map != focus_on_map)
 748     private->focus_on_map = focus_on_map;
 749 }
 750
 751 static gboolean
 752 gdk_directfb_window_raise (GdkWindow *window)
 753 {
 754   GdkWindowObject *parent;
 755
 756   parent = GDK_WINDOW_OBJECT (window)->parent;
 757
 758   if (parent->children->data == window)
 759     return FALSE;
 760
 761   parent->children = g_list_remove (parent->children, window);
 762   parent->children = g_list_prepend (parent->children, window);
 763
 764   return TRUE;
 765 }
 766
 767 static void
 768 gdk_directfb_window_lower (GdkWindow *window)
 769 {
 770   GdkWindowObject *parent;
 771
 772   parent = GDK_WINDOW_OBJECT (window)->parent;
 773
 774   parent->children = g_list_remove (parent->children, window);
 775   parent->children = g_list_append (parent->children, window);
 776 }
 777
 778 static gboolean
 779 all_parents_shown (GdkWindowObject *private)
 780 {
 781   while (GDK_WINDOW_IS_MAPPED (private))
 782     {
 783       if (private->parent)
 784         private = GDK_WINDOW_OBJECT (private)->parent;
 785       else
 786         return TRUE;
 787     }
 788
 789   return FALSE;
 790 }
 791
 792 static void
 793 send_map_events (GdkWindowObject *private)
 794 {
 795   GList     *list;
 796   GdkWindow *event_win;
 797
 798   if (!GDK_WINDOW_IS_MAPPED (private))
 799     return;
 800
 801   event_win = gdk_directfb_other_event_window ((GdkWindow *) private, GDK_MAP);
 802   if (event_win)
 803     gdk_directfb_event_make (event_win, GDK_MAP);
 804
 805   for (list = private->children; list; list = list->next)
 806     send_map_events (list->data);
 807 }
 808
 809 static GdkWindow *
 810 gdk_directfb_find_common_ancestor (GdkWindow *win1,
 811                                    GdkWindow *win2)
 812 {
 813   GdkWindowObject *a;
 814   GdkWindowObject *b;
 815
 816   for (a = GDK_WINDOW_OBJECT (win1); a; a = a->parent)
 817     for (b = GDK_WINDOW_OBJECT (win2); b; b = b->parent)
 818       {
 819         if (a == b)
 820           return GDK_WINDOW (a);
 821       }
 822
 823   return NULL;
 824 }
 825
 826 void
 827 gdk_directfb_window_send_crossing_events (GdkWindow       *src,
 828                                           GdkWindow       *dest,
 829                                           GdkCrossingMode  mode)
 830 {
 831   GdkWindow       *c;
 832   GdkWindow       *win, *last, *next;
 833   GdkEvent        *event;
 834   gint             x, y, x_int, y_int;
 835   GdkModifierType  modifiers;
 836   GSList          *path, *list;
 837   gboolean         non_linear;
 838   GdkWindow       *a;
 839   GdkWindow       *b;
 840   GdkWindow       *event_win;
 841
 842   /* Do a possible cursor change before checking if we need to
 843      generate crossing events so cursor changes due to pointer
 844      grabs work correctly. */
 845   {
 846     static GdkCursorDirectFB *last_cursor = NULL;
 847
 848     GdkWindowObject       *private = GDK_WINDOW_OBJECT (dest);
 849     GdkWindowImplDirectFB *impl    = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
 850     GdkCursorDirectFB     *cursor;
 851
 852     if (_gdk_directfb_pointer_grab_cursor)
 853       cursor = (GdkCursorDirectFB*) _gdk_directfb_pointer_grab_cursor;
 854     else
 855       cursor = (GdkCursorDirectFB*) impl->cursor;
 856
 857     if (cursor != last_cursor)
 858       {
 859         win     = gdk_directfb_window_find_toplevel (dest);
 860         private = GDK_WINDOW_OBJECT (win);
 861         impl    = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
 862
 863         if (impl->window)
 864           impl->window->SetCursorShape (impl->window,
 865                                         cursor->shape,
 866                                         cursor->hot_x, cursor->hot_y);
 867         last_cursor = cursor;
 868       }
 869   }
 870
 871   if (dest == gdk_directfb_window_containing_pointer)
 872     return;
 873
 874   if (gdk_directfb_window_containing_pointer == NULL)
 875     gdk_directfb_window_containing_pointer = g_object_ref (_gdk_parent_root);
 876
 877   if (src)
 878     a = src;
 879   else
 880     a = gdk_directfb_window_containing_pointer;
 881
 882   b = dest;
 883
 884   if (a == b)
 885     return;
 886
 887   /* gdk_directfb_window_containing_pointer might have been destroyed.
 888    * The refcount we hold on it should keep it, but it's parents
 889    * might have died.
 890    */
 891   if (GDK_WINDOW_DESTROYED (a))
 892     a = _gdk_parent_root;
 893
 894   gdk_directfb_mouse_get_info (&x, &y, &modifiers);
 895
 896   c = gdk_directfb_find_common_ancestor (a, b);
 897
 898   non_linear = (c != a) && (c != b);
 899
 900   event_win = gdk_directfb_pointer_event_window (a, GDK_LEAVE_NOTIFY);
 901   if (event_win)
 902     {
 903       event = gdk_directfb_event_make (event_win, GDK_LEAVE_NOTIFY);
 904       event->crossing.subwindow = NULL;
 905
 906       gdk_window_get_origin (a, &x_int, &y_int);
 907
 908       event->crossing.x      = x - x_int;
 909       event->crossing.y      = y - y_int;
 910       event->crossing.x_root = x;
 911       event->crossing.y_root = y;
 912       event->crossing.mode   = mode;
 913
 914       if (non_linear)
 915         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
 916       else if (c == a)
 917         event->crossing.detail = GDK_NOTIFY_INFERIOR;
 918       else
 919         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 920
 921       event->crossing.focus = FALSE;
 922       event->crossing.state = modifiers;
 923     }
 924
 925    /* Traverse up from a to (excluding) c */
 926   if (c != a)
 927     {
 928       last = a;
 929       win = GDK_WINDOW (GDK_WINDOW_OBJECT (a)->parent);
 930       while (win != c)
 931         {
 932           event_win =
 933             gdk_directfb_pointer_event_window (win, GDK_LEAVE_NOTIFY);
 934
 935           if (event_win)
 936             {
 937               event = gdk_directfb_event_make (event_win, GDK_LEAVE_NOTIFY);
 938
 939               event->crossing.subwindow = g_object_ref (last);
 940
 941               gdk_window_get_origin (win, &x_int, &y_int);
 942
 943               event->crossing.x      = x - x_int;
 944               event->crossing.y      = y - y_int;
 945               event->crossing.x_root = x;
 946               event->crossing.y_root = y;
 947               event->crossing.mode   = mode;
 948
 949               if (non_linear)
 950                 event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
 951               else
 952                 event->crossing.detail = GDK_NOTIFY_VIRTUAL;
 953
 954               event->crossing.focus = FALSE;
 955               event->crossing.state = modifiers;
 956             }
 957
 958           last = win;
 959           win = GDK_WINDOW (GDK_WINDOW_OBJECT (win)->parent);
 960         }
 961     }
 962
 963   /* Traverse down from c to b */
 964   if (c != b)
 965     {
 966       path = NULL;
 967       win = GDK_WINDOW (GDK_WINDOW_OBJECT (b)->parent);
 968       while (win != c)
 969         {
 970           path = g_slist_prepend (path, win);
 971           win = GDK_WINDOW (GDK_WINDOW_OBJECT (win)->parent);
 972         }
 973
 974       list = path;
 975       while (list)
 976         {
 977           win = GDK_WINDOW (list->data);
 978           list = g_slist_next (list);
 979
 980           if (list)
 981             next = GDK_WINDOW (list->data);
 982           else
 983             next = b;
 984
 985           event_win =
 986             gdk_directfb_pointer_event_window (win, GDK_ENTER_NOTIFY);
 987
 988           if (event_win)
 989             {
 990               event = gdk_directfb_event_make (event_win, GDK_ENTER_NOTIFY);
 991
 992               event->crossing.subwindow = g_object_ref (next);
 993
 994               gdk_window_get_origin (win, &x_int, &y_int);
 995
 996               event->crossing.x      = x - x_int;
 997               event->crossing.y      = y - y_int;
 998               event->crossing.x_root = x;
 999               event->crossing.y_root = y;
1000               event->crossing.mode   = mode;
1001
1002               if (non_linear)
1003                 event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
1004               else
1005                 event->crossing.detail = GDK_NOTIFY_VIRTUAL;
1006
1007               event->crossing.focus = FALSE;
1008               event->crossing.state = modifiers;
1009             }
1010         }
1011
1012       g_slist_free (path);
1013     }
1014
1015   event_win = gdk_directfb_pointer_event_window (b, GDK_ENTER_NOTIFY);
1016   if (event_win)
1017     {
1018       event = gdk_directfb_event_make (event_win, GDK_ENTER_NOTIFY);
1019
1020       event->crossing.subwindow = NULL;
1021
1022       gdk_window_get_origin (b, &x_int, &y_int);
1023
1024       event->crossing.x      = x - x_int;
1025       event->crossing.y      = y - y_int;
1026       event->crossing.x_root = x;
1027       event->crossing.y_root = y;
1028       event->crossing.mode   = mode;
1029
1030       if (non_linear)
1031         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
1032       else if (c==a)
1033         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
1034       else
1035         event->crossing.detail = GDK_NOTIFY_INFERIOR;
1036
1037       event->crossing.focus = FALSE;
1038       event->crossing.state = modifiers;
1039     }
1040
1041   if (mode != GDK_CROSSING_GRAB)
1042     {
1043       //this seems to cause focus to change as the pointer moves yuck
1044       //gdk_directfb_change_focus (b);
1045       if (b != gdk_directfb_window_containing_pointer)
1046         {
1047           g_object_unref (gdk_directfb_window_containing_pointer);
1048           gdk_directfb_window_containing_pointer = g_object_ref (b);
1049         }
1050     }
1051 }
1052
1053 static void
1054 show_window_internal (GdkWindow *window,
1055                       gboolean   raise)
1056 {
1057   GdkWindowObject       *private;
1058   GdkWindowImplDirectFB *impl;
1059   GdkWindow             *mousewin;
1060
1061   private = GDK_WINDOW_OBJECT (window);
1062   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1063
1064   if (!private->destroyed && !GDK_WINDOW_IS_MAPPED (private))
1065     {
1066       private->state &= ~GDK_WINDOW_STATE_WITHDRAWN;
1067
1068       if (raise)
1069         gdk_window_raise (window);
1070
1071       if (all_parents_shown (GDK_WINDOW_OBJECT (private)->parent))
1072         {
1073           send_map_events (private);
1074
1075           mousewin = gdk_window_at_pointer (NULL, NULL);
1076           gdk_directfb_window_send_crossing_events (NULL, mousewin,
1077                                                     GDK_CROSSING_NORMAL);
1078
1079           if (private->input_only)
1080             return;
1081
1082           gdk_window_invalidate_rect (window, NULL, TRUE);
1083         }
1084     }
1085
1086   if (impl->window)
1087     {
1088       if (gdk_directfb_apply_focus_opacity)
1089         impl->window->SetOpacity (impl->window,
1090                                   (impl->opacity >> 1) + (impl->opacity >> 2));
1091       else
1092         impl->window->SetOpacity (impl->window, impl->opacity);
1093           /* if its the first window focus it */
1094     }
1095 }
1096
1097 void
1098 gdk_window_show_unraised (GdkWindow *window)
1099 {
1100   g_return_if_fail (GDK_IS_WINDOW (window));
1101
1102   show_window_internal (window, FALSE);
1103 }
1104
1105 void
1106 gdk_window_show (GdkWindow *window)
1107 {
1108   g_return_if_fail (GDK_IS_WINDOW (window));
1109
1110   show_window_internal (window, TRUE);
1111 }
1112
1113 void
1114 gdk_window_hide (GdkWindow *window)
1115 {
1116   GdkWindowObject       *private;
1117   GdkWindowImplDirectFB *impl;
1118   GdkWindow             *mousewin;
1119   GdkWindow             *event_win;
1120
1121   g_return_if_fail (GDK_IS_WINDOW (window));
1122
1123   private = GDK_WINDOW_OBJECT (window);
1124   impl    = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1125
1126   if (impl->window)
1127     impl->window->SetOpacity (impl->window, 0);
1128
1129   if (!private->destroyed && GDK_WINDOW_IS_MAPPED (private))
1130     {
1131       GdkEvent *event;
1132
1133       private->state |= GDK_WINDOW_STATE_WITHDRAWN;
1134
1135       if (!private->input_only && private->parent)
1136         {
1137           _gdk_windowing_window_clear_area (GDK_WINDOW (private->parent),
1138                                             private->x,
1139                                             private->y,
1140                                             impl->drawable.width,
1141                                             impl->drawable.height);
1142         }
1143
1144       event_win = gdk_directfb_other_event_window (window, GDK_UNMAP);
1145       if (event_win)
1146         event = gdk_directfb_event_make (event_win, GDK_UNMAP);
1147
1148       mousewin = gdk_window_at_pointer (NULL, NULL);
1149       gdk_directfb_window_send_crossing_events (NULL,
1150                                                 mousewin,
1151                                                 GDK_CROSSING_NORMAL);
1152
1153       if (window == _gdk_directfb_pointer_grab_window)
1154         gdk_pointer_ungrab (GDK_CURRENT_TIME);
1155       if (window == _gdk_directfb_keyboard_grab_window)
1156         gdk_keyboard_ungrab (GDK_CURRENT_TIME);
1157     }
1158 }
1159
1160 void
1161 gdk_window_withdraw (GdkWindow *window)
1162 {
1163   g_return_if_fail (GDK_IS_WINDOW (window));
1164
1165   /* for now this should be enough */
1166   gdk_window_hide (window);
1167 }
1168
1169 void
1170 gdk_window_move (GdkWindow *window,
1171                  gint       x,
1172                  gint       y)
1173 {
1174   GdkWindowObject       *private;
1175   GdkWindowImplDirectFB *impl;
1176
1177   g_return_if_fail (GDK_IS_WINDOW (window));
1178
1179   private = GDK_WINDOW_OBJECT (window);
1180   impl    = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1181
1182   if (impl->window)
1183     {
1184           private->x = x;
1185           private->y = y;
1186       impl->window->MoveTo (impl->window, x, y);
1187     }
1188   else
1189     {
1190           gint width=impl->drawable.width;
1191           gint height=impl->drawable.height;
1192       GdkRectangle  old =
1193       { private->x, private->y,width,height };
1194
1195       _gdk_directfb_move_resize_child (window, x, y, width, height);
1196       _gdk_directfb_calc_abs (window);
1197
1198       if (GDK_WINDOW_IS_MAPPED (private))
1199         {
1200           GdkWindow    *mousewin;
1201           GdkRectangle  new = { x, y, width, height };
1202
1203           gdk_rectangle_union (&new, &old, &new);
1204           gdk_window_invalidate_rect (GDK_WINDOW (private->parent), &new,TRUE);
1205
1206           /* The window the pointer is in might have changed */
1207           mousewin = gdk_window_at_pointer (NULL, NULL);
1208           gdk_directfb_window_send_crossing_events (NULL, mousewin,
1209                                                     GDK_CROSSING_NORMAL);
1210         }
1211     }
1212 }
1213
1214 void
1215 gdk_window_resize (GdkWindow *window,
1216                    gint       width,
1217                    gint       height)
1218 {
1219   GdkWindowObject *private;
1220   gint             x, y;
1221
1222   g_return_if_fail (GDK_IS_WINDOW (window));
1223
1224   private = GDK_WINDOW_OBJECT (window);
1225
1226   x = private->x;
1227   y = private->y;
1228
1229   if (private->parent && (private->parent->window_type != GDK_WINDOW_CHILD))
1230     {
1231       GdkWindowChildHandlerData *data;
1232
1233       data = g_object_get_data (G_OBJECT (private->parent),
1234                                 "gdk-window-child-handler");
1235
1236       if (data)
1237         (*data->get_pos) (window, &x, &y, data->user_data);
1238     }
1239
1240   gdk_window_move_resize (window, x, y, width, height);
1241 }
1242
1243 void
1244 _gdk_directfb_move_resize_child (GdkWindow *window,
1245                                  gint       x,
1246                                  gint       y,
1247                                  gint       width,
1248                                  gint       height)
1249 {
1250   GdkWindowObject       *private;
1251   GdkWindowImplDirectFB *impl;
1252   GdkWindowImplDirectFB *parent_impl;
1253   GList                 *list;
1254
1255   g_return_if_fail (GDK_IS_WINDOW (window));
1256
1257   private = GDK_WINDOW_OBJECT (window);
1258   impl    = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1259
1260   private->x = x;
1261   private->y = y;
1262
1263   impl->drawable.width  = width;
1264   impl->drawable.height = height;
1265
1266   if (!private->input_only)
1267     {
1268       if (impl->drawable.surface)
1269         {
1270           GdkDrawableImplDirectFB *dimpl;
1271           dimpl    = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
1272           impl->drawable.surface->Release (impl->drawable.surface);
1273           impl->drawable.surface = NULL;
1274           cairo_surface_destroy(dimpl->cairo_surface);
1275           dimpl->cairo_surface= NULL;
1276         }
1277
1278       parent_impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (private->parent)->impl);
1279
1280       if (parent_impl->drawable.surface)
1281         {
1282           DFBRectangle rect = { x, y, width, height };
1283
1284           parent_impl->drawable.surface->GetSubSurface (parent_impl->drawable.surface,
1285                                                         &rect,
1286                                                         &impl->drawable.surface);
1287         }
1288     }
1289
1290   for (list = private->children; list; list = list->next)
1291     {
1292       private = GDK_WINDOW_OBJECT (list->data);
1293           impl  = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1294       _gdk_directfb_move_resize_child (list->data,
1295                                        private->x, private->y,
1296                                        impl->drawable.width, impl->drawable.height);
1297     }
1298 }
1299
1300 void
1301 gdk_window_move_resize (GdkWindow *window,
1302                         gint       x,
1303                         gint       y,
1304                         gint       width,
1305                         gint       height)
1306 {
1307   GdkWindowObject       *private;
1308   GdkWindowImplDirectFB *impl;
1309
1310   g_return_if_fail (GDK_IS_WINDOW (window));
1311
1312   private = GDK_WINDOW_OBJECT (window);
1313   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1314
1315   if (width < 1)
1316      width = 1;
1317   if (height < 1)
1318     height = 1;
1319
1320   if (private->destroyed ||
1321       (private->x == x  &&  private->y == y  &&
1322        impl->drawable.width == width  &&  impl->drawable.height == height))
1323     return;
1324
1325   if (private->parent && (private->parent->window_type != GDK_WINDOW_CHILD))
1326     {
1327       GdkWindowChildHandlerData *data;
1328
1329       data = g_object_get_data (G_OBJECT (private->parent),
1330                                 "gdk-window-child-handler");
1331
1332       if (data &&
1333           (*data->changed) (window, x, y, width, height, data->user_data))
1334         return;
1335     }
1336
1337   if (impl->drawable.width == width  &&  impl->drawable.height == height)
1338     {
1339       gdk_window_move (window, x, y);
1340     }
1341   else if (impl->window)
1342     {
1343           private->x = x;
1344           private->y = y;
1345       impl->window->MoveTo (impl->window, x, y);
1346       impl->window->Resize (impl->window, width, height);
1347     }
1348   else
1349     {
1350       GdkRectangle  old =
1351       { private->x, private->y, impl->drawable.width, impl->drawable.height };
1352       _gdk_directfb_move_resize_child (window, x, y, width, height);
1353       _gdk_directfb_calc_abs (window);
1354
1355       if (GDK_WINDOW_IS_MAPPED (private))
1356         {
1357           GdkWindow    *mousewin;
1358           GdkRectangle  new = { x, y, width, height };
1359
1360           gdk_rectangle_union (&new, &old, &new);
1361           gdk_window_invalidate_rect (GDK_WINDOW (private->parent), &new,TRUE);
1362
1363           /* The window the pointer is in might have changed */
1364           mousewin = gdk_window_at_pointer (NULL, NULL);
1365           gdk_directfb_window_send_crossing_events (NULL, mousewin,
1366                                                     GDK_CROSSING_NORMAL);
1367         }
1368     }
1369 }
1370
1371 void
1372 gdk_window_reparent (GdkWindow *window,
1373                      GdkWindow *new_parent,
1374                      gint       x,
1375                      gint       y)
1376 {
1377   GdkWindowObject *window_private;
1378   GdkWindowObject *parent_private;
1379   GdkWindowObject *old_parent_private;
1380   GdkWindowImplDirectFB *impl;
1381   GdkWindowImplDirectFB *parent_impl;
1382   GdkVisual             *visual;
1383
1384   g_return_if_fail (GDK_IS_WINDOW (window));
1385
1386   if (GDK_WINDOW_DESTROYED (window))
1387     return;
1388
1389   if (!new_parent)
1390     new_parent = _gdk_parent_root;
1391
1392   window_private = (GdkWindowObject *) window;
1393   old_parent_private = (GdkWindowObject *) window_private->parent;
1394   parent_private = (GdkWindowObject *) new_parent;
1395   parent_impl = GDK_WINDOW_IMPL_DIRECTFB (parent_private->impl);
1396   visual = gdk_drawable_get_visual (window);
1397
1398   /* already parented */
1399   if( window_private->parent == (GdkWindowObject *)new_parent )
1400           return;
1401
1402   window_private->parent = (GdkWindowObject *) new_parent;
1403
1404   if (old_parent_private)
1405     {
1406       old_parent_private->children =
1407         g_list_remove (old_parent_private->children, window);
1408     }
1409
1410     parent_private->children = g_list_prepend (parent_private->children, window);
1411
1412     impl = GDK_WINDOW_IMPL_DIRECTFB (window_private->impl);
1413
1414     if( impl->drawable.surface ) {
1415         impl->drawable.surface->Release (impl->drawable.surface);
1416         impl->drawable.surface = NULL;
1417     }
1418
1419     if( impl->window != NULL ) {
1420         gdk_directfb_window_id_table_remove (impl->dfb_id);
1421         impl->window->SetOpacity (impl->window,0);
1422                 impl->window->Close(impl->window);
1423         impl->window->Release(impl->window);
1424         impl->window = NULL;
1425     }
1426
1427     //create window were a child of the root now
1428     if( window_private->parent == (GdkWindowObject *)_gdk_parent_root)  {
1429         DFBWindowDescription  desc;
1430         DFBWindowOptions  window_options = DWOP_NONE;
1431         desc.flags = DWDESC_CAPS;
1432         if( window_private->input_only ) {
1433             desc.caps = DWCAPS_INPUTONLY;
1434         } else {
1435             desc.flags |= DWDESC_PIXELFORMAT;
1436             desc.pixelformat = ((GdkVisualDirectFB *) visual)->format;
1437             if (DFB_PIXELFORMAT_HAS_ALPHA (desc.pixelformat)) {
1438                 desc.flags |= DWDESC_CAPS;
1439                 desc.caps = DWCAPS_ALPHACHANNEL;
1440             }
1441        }
1442        if( window_private->window_type ==  GDK_WINDOW_CHILD )
1443            window_private->window_type = GDK_WINDOW_TOPLEVEL;
1444         desc.flags |= ( DWDESC_WIDTH | DWDESC_HEIGHT |
1445                       DWDESC_POSX  | DWDESC_POSY );
1446         desc.posx   = x;
1447         desc.posy   = y;
1448         desc.width  = impl->drawable.width;
1449         desc.height = impl->drawable.height;
1450         if (!create_directfb_window (impl, &desc, window_options))
1451         {
1452                   g_assert(0);
1453           _gdk_window_destroy (window, FALSE);
1454           return;
1455         }
1456         /* we hold a reference count on ourselves */
1457         g_object_ref (window);
1458         impl->window->GetID (impl->window, &impl->dfb_id);
1459         gdk_directfb_window_id_table_insert (impl->dfb_id, window);
1460         gdk_directfb_event_windows_add (window);
1461    } else {
1462           DFBRectangle rect = { x, y, impl->drawable.width,
1463                                      impl->drawable.height};
1464           impl->window = NULL;
1465           parent_impl->drawable.surface->GetSubSurface (
1466                           parent_impl->drawable.surface,
1467                           &rect,
1468                           &impl->drawable.surface);
1469    }
1470 }
1471
1472 void
1473 _gdk_windowing_window_clear_area (GdkWindow *window,
1474                                   gint       x,
1475                                   gint       y,
1476                                   gint       width,
1477                                   gint       height)
1478 {
1479   GdkWindowObject         *private;
1480   GdkDrawableImplDirectFB *impl;
1481   GdkPixmap               *bg_pixmap;
1482   GdkWindowObject         *relative_to;
1483   GdkGC                   *gc = NULL;
1484   gint                     dx = 0;
1485   gint                     dy = 0;
1486
1487   g_return_if_fail (GDK_IS_WINDOW (window));
1488
1489   if (GDK_WINDOW_DESTROYED (window))
1490     return;
1491
1492   private = GDK_WINDOW_OBJECT (window);
1493
1494   impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
1495
1496   /**
1497         Follow XClearArea definition for zero height width
1498   **/
1499   if( width == 0 )
1500                 width = impl->width-x;
1501   if( height == 0 )
1502                 height = impl->height-y;
1503
1504   bg_pixmap = private->bg_pixmap;
1505
1506   for (relative_to = private;
1507        relative_to && bg_pixmap == GDK_PARENT_RELATIVE_BG;
1508        relative_to = relative_to->parent)
1509     {
1510       bg_pixmap = relative_to->bg_pixmap;
1511       dx += relative_to->x;
1512       dy += relative_to->y;
1513     }
1514
1515   if (bg_pixmap == GDK_NO_BG)
1516     return;
1517
1518   if (bg_pixmap && bg_pixmap != GDK_PARENT_RELATIVE_BG)
1519     {
1520       GdkGCValues  values;
1521
1522       values.fill = GDK_TILED;
1523       values.tile = bg_pixmap;
1524       values.ts_x_origin = - dx;
1525       values.ts_y_origin = - dy;
1526
1527       gc = gdk_gc_new_with_values (GDK_DRAWABLE (impl), &values,
1528                                    GDK_GC_FILL | GDK_GC_TILE |
1529                                    GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN);
1530     }
1531   else
1532     {
1533       /* GDK_PARENT_RELATIVE_BG, but no pixmap,
1534          get the color from the parent window. */
1535
1536       GdkGCValues  values;
1537
1538       values.foreground = relative_to->bg_color;
1539
1540       gc = gdk_gc_new_with_values (GDK_DRAWABLE (impl), &values,
1541                                    GDK_GC_FOREGROUND);
1542     }
1543
1544   gdk_draw_rectangle (GDK_DRAWABLE (impl),
1545                                 gc, TRUE, x, y, width, height);
1546
1547   if (gc)
1548     g_object_unref (gc);
1549 }
1550
1551 void
1552 _gdk_windowing_window_clear_area_e (GdkWindow *window,
1553                                     gint       x,
1554                                     gint       y,
1555                                     gint       width,
1556                                     gint       height)
1557 {
1558   GdkRectangle  rect;
1559   GdkWindowObject       *private;
1560   GdkWindowImplDirectFB *impl;
1561
1562   g_return_if_fail (GDK_IS_WINDOW (window));
1563
1564   private = GDK_WINDOW_OBJECT (window);
1565   impl    = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
1566
1567   /**
1568         Follow XClearArea definition for zero height width
1569   **/
1570   if( width == 0 )
1571                 width = impl->drawable.width-x;
1572   if( height == 0 )
1573                 height = impl->drawable.height-y;
1574
1575   rect.x = x;
1576   rect.y = y;
1577   rect.width = width;
1578   rect.height = height;
1579
1580   g_return_if_fail (GDK_IS_WINDOW (window));
1581
1582   if (GDK_WINDOW_DESTROYED (window))
1583     return;
1584
1585   _gdk_windowing_window_clear_area (window, x, y, width, height);
1586
1587   gdk_window_invalidate_rect (window, &rect, TRUE);
1588 }
1589
1590 void
1591 gdk_window_raise (GdkWindow *window)
1592 {
1593   GdkWindowImplDirectFB *impl;
1594
1595   g_return_if_fail (GDK_IS_WINDOW (window));
1596
1597   if (GDK_WINDOW_DESTROYED (window))
1598     return;
1599
1600   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
1601
1602   if (impl->window)
1603     {
1604       DFBResult ret;
1605
1606       ret = impl->window->RaiseToTop (impl->window);
1607       if (ret)
1608         DirectFBError ("gdkwindow-directfb.c: RaiseToTop", ret);
1609       else
1610         gdk_directfb_window_raise (window);
1611     }
1612   else
1613     {
1614       if (gdk_directfb_window_raise (window))
1615         gdk_window_invalidate_rect (window, NULL, TRUE);
1616     }
1617 }
1618
1619 void
1620 gdk_window_lower (GdkWindow *window)
1621 {
1622   GdkWindowImplDirectFB *impl;
1623
1624   g_return_if_fail (GDK_IS_WINDOW (window));
1625
1626   if (GDK_WINDOW_DESTROYED (window))
1627     return;
1628
1629   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
1630
1631   if (impl->window)
1632     {
1633       DFBResult ret;
1634
1635       ret = impl->window->LowerToBottom (impl->window);
1636       if (ret)
1637         DirectFBError ("gdkwindow-directfb.c: LowerToBottom", ret);
1638       else
1639         gdk_directfb_window_lower (window);
1640     }
1641   else
1642     {
1643       gdk_directfb_window_lower (window);
1644       gdk_window_invalidate_rect (window, NULL, TRUE);
1645     }
1646 }
1647
1648 void
1649 gdk_window_set_hints (GdkWindow *window,
1650                       gint       x,
1651                       gint       y,
1652                       gint       min_width,
1653                       gint       min_height,
1654                       gint       max_width,
1655                       gint       max_height,
1656                       gint       flags)
1657 {
1658   g_return_if_fail (GDK_IS_WINDOW (window));
1659
1660   if (GDK_WINDOW_DESTROYED (window))
1661     return;
1662
1663   /* N/A */
1664 }
1665
1666 void
1667 gdk_window_set_geometry_hints (GdkWindow      *window,
1668                                GdkGeometry    *geometry,
1669                                GdkWindowHints  geom_mask)
1670 {
1671   g_return_if_fail (GDK_IS_WINDOW (window));
1672
1673   if (GDK_WINDOW_DESTROYED (window))
1674     return;
1675
1676   /* N/A */
1677 }
1678
1679 void
1680 gdk_window_set_title (GdkWindow   *window,
1681                       const gchar *title)
1682 {
1683   g_return_if_fail (GDK_IS_WINDOW (window));
1684
1685   if (GDK_WINDOW_DESTROYED (window))
1686     return;
1687
1688   /* N/A */
1689 }
1690
1691 void
1692 gdk_window_set_role (GdkWindow   *window,
1693                      const gchar *role)
1694 {
1695   g_return_if_fail (GDK_IS_WINDOW (window));
1696
1697   if (GDK_WINDOW_DESTROYED (window))
1698     return;
1699
1700   /* N/A */
1701 }
1702
1703 void
1704 gdk_window_set_transient_for (GdkWindow *window,
1705                               GdkWindow *parent)
1706 {
1707   GdkWindowObject *private;
1708   GdkWindowObject *root;
1709   gint i;
1710
1711   g_return_if_fail (GDK_IS_WINDOW (window));
1712   g_return_if_fail (GDK_IS_WINDOW (parent));
1713
1714   private = GDK_WINDOW_OBJECT (window);
1715   root    = GDK_WINDOW_OBJECT (_gdk_parent_root);
1716
1717   g_return_if_fail (GDK_WINDOW (private->parent) == _gdk_parent_root);
1718   g_return_if_fail (GDK_WINDOW (GDK_WINDOW_OBJECT (parent)->parent) == _gdk_parent_root);
1719
1720   root->children = g_list_remove (root->children, window);
1721
1722   i = g_list_index (root->children, parent);
1723   if (i < 0)
1724     root->children = g_list_prepend (root->children, window);
1725   else
1726     root->children = g_list_insert (root->children, window, i);
1727 }
1728
1729 void
1730 gdk_window_set_background (GdkWindow *window,
1731                            const GdkColor  *color)
1732 {
1733   GdkWindowObject *private;
1734
1735   g_return_if_fail (GDK_IS_WINDOW (window));
1736
1737   g_return_if_fail (color != NULL);
1738
1739   private = GDK_WINDOW_OBJECT (window);
1740   private->bg_color = *color;
1741
1742   if (private->bg_pixmap &&
1743       private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1744       private->bg_pixmap != GDK_NO_BG)
1745     g_object_unref (private->bg_pixmap);
1746
1747   private->bg_pixmap = NULL;
1748 }
1749
1750 void
1751 gdk_window_set_back_pixmap (GdkWindow *window,
1752                             GdkPixmap *pixmap,
1753                             gint       parent_relative)
1754 {
1755   GdkWindowObject *private;
1756   GdkPixmap       *old_pixmap;
1757
1758   g_return_if_fail (GDK_IS_WINDOW (window));
1759   g_return_if_fail (pixmap == NULL || !parent_relative);
1760
1761   private = GDK_WINDOW_OBJECT (window);
1762   old_pixmap = private->bg_pixmap;
1763
1764   if (private->bg_pixmap &&
1765       private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1766       private->bg_pixmap != GDK_NO_BG)
1767     {
1768       g_object_unref (private->bg_pixmap);
1769     }
1770
1771   if (parent_relative)
1772     {
1773       private->bg_pixmap = GDK_PARENT_RELATIVE_BG;
1774     }
1775   else
1776     {
1777       if (pixmap && pixmap != GDK_NO_BG && pixmap != GDK_PARENT_RELATIVE_BG)
1778         g_object_ref (pixmap);
1779
1780       private->bg_pixmap = pixmap;
1781     }
1782 }
1783
1784 void
1785 gdk_window_set_cursor (GdkWindow *window,
1786                        GdkCursor *cursor)
1787 {
1788   GdkWindowImplDirectFB *impl;
1789   GdkCursor             *old_cursor;
1790
1791   g_return_if_fail (GDK_IS_WINDOW (window));
1792
1793   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
1794   old_cursor = impl->cursor;
1795
1796   impl->cursor = (cursor ?
1797                   gdk_cursor_ref (cursor) : gdk_cursor_new (GDK_LEFT_PTR));
1798
1799   if (gdk_window_at_pointer (NULL, NULL) == window)
1800     {
1801       /* This is a bit evil but we want to keep all cursor changes in
1802          one place, so let gdk_directfb_window_send_crossing_events
1803          do the work for us. */
1804
1805       gdk_directfb_window_send_crossing_events (window, window,
1806                                                 GDK_CROSSING_NORMAL);
1807     }
1808   else if (impl->window)
1809     {
1810       GdkCursorDirectFB *dfb_cursor = (GdkCursorDirectFB *) impl->cursor;
1811
1812       /* this branch takes care of setting the cursor for unmapped windows */
1813
1814       impl->window->SetCursorShape (impl->window,
1815                                     dfb_cursor->shape,
1816                                     dfb_cursor->hot_x, dfb_cursor->hot_y);
1817     }
1818
1819   if (old_cursor)
1820     gdk_cursor_unref (old_cursor);
1821 }
1822
1823 void
1824 gdk_window_get_geometry (GdkWindow *window,
1825                          gint      *x,
1826                          gint      *y,
1827                          gint      *width,
1828                          gint      *height,
1829                          gint      *depth)
1830 {
1831   GdkWindowObject         *private;
1832   GdkDrawableImplDirectFB *impl;
1833
1834   g_return_if_fail (GDK_IS_WINDOW (window));
1835
1836   private = GDK_WINDOW_OBJECT (window);
1837   impl    = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
1838
1839   if (!GDK_WINDOW_DESTROYED (window))
1840     {
1841       if (x)
1842         *x = private->x;
1843
1844       if (y)
1845         *y = private->y;
1846
1847       if (width)
1848         *width = impl->width;
1849
1850       if (height)
1851         *height = impl->height;
1852
1853       if (depth)
1854         *depth = DFB_BITS_PER_PIXEL(impl->format);
1855     }
1856 }
1857
1858 void
1859 _gdk_directfb_calc_abs (GdkWindow *window)
1860 {
1861   GdkWindowObject         *private;
1862   GdkDrawableImplDirectFB *impl;
1863   GList                   *list;
1864
1865   g_return_if_fail (GDK_IS_WINDOW (window));
1866
1867   private = GDK_WINDOW_OBJECT (window);
1868   impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
1869
1870   impl->abs_x = private->x;
1871   impl->abs_y = private->y;
1872
1873   if (private->parent)
1874     {
1875       GdkDrawableImplDirectFB *parent_impl =
1876         GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (private->parent)->impl);
1877
1878       impl->abs_x += parent_impl->abs_x;
1879       impl->abs_y += parent_impl->abs_y;
1880     }
1881
1882   for (list = private->children; list; list = list->next)
1883     {
1884       _gdk_directfb_calc_abs (list->data);
1885     }
1886 }
1887
1888 gboolean
1889 gdk_window_get_origin (GdkWindow *window,
1890                        gint      *x,
1891                        gint      *y)
1892 {
1893   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
1894
1895   if (!GDK_WINDOW_DESTROYED (window))
1896     {
1897       GdkDrawableImplDirectFB *impl;
1898
1899       impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
1900
1901       if (x)
1902         *x = impl->abs_x;
1903       if (y)
1904         *y = impl->abs_y;
1905
1906       return TRUE;
1907     }
1908
1909   return FALSE;
1910 }
1911
1912 gboolean
1913 gdk_window_get_deskrelative_origin (GdkWindow *window,
1914                                     gint      *x,
1915                                     gint      *y)
1916 {
1917   return gdk_window_get_origin (window, x, y);
1918 }
1919
1920 void
1921 gdk_window_get_root_origin (GdkWindow *window,
1922                             gint      *x,
1923                             gint      *y)
1924 {
1925   GdkWindowObject *rover;
1926
1927   g_return_if_fail (GDK_IS_WINDOW (window));
1928
1929   rover = (GdkWindowObject*) window;
1930   if (x)
1931     *x = 0;
1932   if (y)
1933     *y = 0;
1934
1935   if (GDK_WINDOW_DESTROYED (window))
1936     return;
1937
1938   while (rover->parent && ((GdkWindowObject*) rover->parent)->parent)
1939     rover = (GdkWindowObject *) rover->parent;
1940   if (rover->destroyed)
1941     return;
1942
1943   if (x)
1944     *x = rover->x;
1945   if (y)
1946     *y = rover->y;
1947 }
1948
1949 GdkWindow *
1950 _gdk_windowing_window_get_pointer (GdkDisplay      *display,
1951                                    GdkWindow       *window,
1952                                    gint            *x,
1953                                    gint            *y,
1954                                    GdkModifierType *mask)
1955 {
1956   GdkWindow               *retval = NULL;
1957   gint                     rx, ry, wx, wy;
1958   GdkDrawableImplDirectFB *impl;
1959
1960   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1961
1962   if (!window)
1963     window = _gdk_parent_root;
1964
1965   gdk_directfb_mouse_get_info (&rx, &ry, mask);
1966
1967   wx = rx;
1968   wy = ry;
1969   retval = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
1970
1971   impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
1972
1973   if (x)
1974     *x = rx - impl->abs_x;
1975   if (y)
1976     *y = ry - impl->abs_y;
1977
1978   return retval;
1979 }
1980
1981 GdkWindow *
1982 _gdk_windowing_window_at_pointer (GdkDisplay *display,
1983                                   gint       *win_x,
1984                                   gint       *win_y)
1985 {
1986   GdkWindow *retval;
1987   gint       wx, wy;
1988
1989   if (!win_x || !win_y)
1990   gdk_directfb_mouse_get_info (&wx, &wy, NULL);
1991
1992   if (win_x)
1993     wx = *win_x;
1994
1995   if (win_y)
1996     wy = *win_y;
1997
1998   retval = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
1999
2000   if (win_x)
2001     *win_x = wx;
2002
2003   if (win_y)
2004     *win_y = wy;
2005
2006   return retval;
2007 }
2008
2009 void
2010 _gdk_windowing_get_pointer (GdkDisplay       *display,
2011                             GdkScreen       **screen,
2012                             gint             *x,
2013                             gint             *y,
2014                             GdkModifierType  *mask)
2015 {
2016 (void)screen;
2017 if(screen) {
2018         *screen = gdk_display_get_default_screen  (display);
2019 }
2020 _gdk_windowing_window_get_pointer (display,
2021                                    _gdk_windowing_window_at_pointer(display,NULL,NULL),x,y,mask);
2022
2023 }
2024
2025 GdkEventMask
2026 gdk_window_get_events (GdkWindow *window)
2027 {
2028   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
2029
2030   if (GDK_WINDOW_DESTROYED (window))
2031     return 0;
2032   else
2033     return GDK_WINDOW_OBJECT (window)->event_mask;
2034 }
2035
2036 void
2037 gdk_window_set_events (GdkWindow    *window,
2038                        GdkEventMask  event_mask)
2039 {
2040   g_return_if_fail (GDK_IS_WINDOW (window));
2041
2042   if (event_mask & GDK_BUTTON_MOTION_MASK)
2043     event_mask |= (GDK_BUTTON1_MOTION_MASK |
2044                    GDK_BUTTON2_MOTION_MASK |
2045                    GDK_BUTTON3_MOTION_MASK);
2046
2047   GDK_WINDOW_OBJECT (window)->event_mask = event_mask;
2048 }
2049
2050 void
2051 gdk_window_shape_combine_mask (GdkWindow *window,
2052                                GdkBitmap *mask,
2053                                gint       x,
2054                                gint       y)
2055 {
2056 }
2057
2058 void
2059 gdk_window_input_shape_combine_mask (GdkWindow *window,
2060                                     GdkBitmap *mask,
2061                                     gint       x,
2062                                     gint       y)
2063 {
2064 }
2065
2066 void
2067 gdk_window_shape_combine_region (GdkWindow *window,
2068                                  GdkRegion *shape_region,
2069                                  gint       offset_x,
2070                                  gint       offset_y)
2071 {
2072 }
2073
2074 void
2075 gdk_window_input_shape_combine_region (GdkWindow *window,
2076                                       GdkRegion *shape_region,
2077                                       gint       offset_x,
2078                                       gint       offset_y)
2079 {
2080 }
2081
2082 void
2083 gdk_window_set_override_redirect (GdkWindow *window,
2084                                   gboolean   override_redirect)
2085 {
2086   g_return_if_fail (GDK_IS_WINDOW (window));
2087
2088   if (GDK_WINDOW_DESTROYED (window))
2089     return;
2090
2091   /* N/A */
2092 }
2093
2094 void
2095 gdk_window_set_icon_list (GdkWindow *window,
2096                           GList     *pixbufs)
2097 {
2098   g_return_if_fail (GDK_IS_WINDOW (window));
2099
2100   if (GDK_WINDOW_DESTROYED (window))
2101     return;
2102
2103   /* N/A */
2104 }
2105
2106 void
2107 gdk_window_set_icon (GdkWindow *window,
2108                      GdkWindow *icon_window,
2109                      GdkPixmap *pixmap,
2110                      GdkBitmap *mask)
2111 {
2112   g_return_if_fail (GDK_IS_WINDOW (window));
2113
2114   if (GDK_WINDOW_DESTROYED (window))
2115     return;
2116
2117   /* N/A */
2118 }
2119
2120 void
2121 gdk_window_set_icon_name (GdkWindow   *window,
2122                           const gchar *name)
2123 {
2124   g_return_if_fail (GDK_IS_WINDOW (window));
2125
2126   if (GDK_WINDOW_DESTROYED (window))
2127     return;
2128
2129   /* N/A */
2130 }
2131
2132 void
2133 gdk_window_iconify (GdkWindow *window)
2134 {
2135   g_return_if_fail (GDK_IS_WINDOW (window));
2136
2137   if (GDK_WINDOW_DESTROYED (window))
2138     return;
2139
2140   gdk_window_hide (window);
2141 }
2142
2143 void
2144 gdk_window_deiconify (GdkWindow *window)
2145 {
2146   g_return_if_fail (GDK_IS_WINDOW (window));
2147
2148   if (GDK_WINDOW_DESTROYED (window))
2149     return;
2150
2151   gdk_window_show (window);
2152 }
2153
2154 void
2155 gdk_window_stick (GdkWindow *window)
2156 {
2157   g_return_if_fail (GDK_IS_WINDOW (window));
2158
2159   if (GDK_WINDOW_DESTROYED (window))
2160     return;
2161
2162   /* N/A */
2163 }
2164
2165 void
2166 gdk_window_unstick (GdkWindow *window)
2167 {
2168   g_return_if_fail (GDK_IS_WINDOW (window));
2169
2170   if (GDK_WINDOW_DESTROYED (window))
2171     return;
2172
2173   /* N/A */
2174 }
2175
2176 void
2177 gdk_directfb_window_set_opacity (GdkWindow *window,
2178                                  guchar     opacity)
2179 {
2180   GdkWindowImplDirectFB *impl;
2181
2182   g_return_if_fail (GDK_IS_WINDOW (window));
2183
2184   if (GDK_WINDOW_DESTROYED (window))
2185     return;
2186
2187   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
2188
2189   impl->opacity = opacity;
2190
2191   if (impl->window && GDK_WINDOW_IS_MAPPED (window))
2192     {
2193       if (gdk_directfb_apply_focus_opacity &&
2194           window == gdk_directfb_focused_window)
2195         impl->window->SetOpacity (impl->window,
2196                                   (impl->opacity >> 1) + (impl->opacity >> 2));
2197       else
2198         impl->window->SetOpacity (impl->window, impl->opacity);
2199     }
2200 }
2201
2202 void
2203 gdk_window_focus (GdkWindow *window,
2204                   guint32    timestamp)
2205 {
2206   GdkWindow *toplevel;
2207
2208   g_return_if_fail (GDK_IS_WINDOW (window));
2209
2210   if (GDK_WINDOW_DESTROYED (window))
2211     return;
2212
2213   toplevel = gdk_directfb_window_find_toplevel (window);
2214   if (toplevel != _gdk_parent_root)
2215     {
2216       GdkWindowImplDirectFB *impl;
2217
2218       impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
2219
2220       impl->window->RequestFocus (impl->window);
2221     }
2222 }
2223
2224 void
2225 gdk_window_maximize (GdkWindow *window)
2226 {
2227   g_return_if_fail (GDK_IS_WINDOW (window));
2228
2229   if (GDK_WINDOW_DESTROYED (window))
2230     return;
2231
2232   /* N/A */
2233 }
2234
2235 void
2236 gdk_window_unmaximize (GdkWindow *window)
2237 {
2238   g_return_if_fail (GDK_IS_WINDOW (window));
2239
2240   if (GDK_WINDOW_DESTROYED (window))
2241     return;
2242
2243   /* N/A */
2244 }
2245
2246 void
2247 gdk_window_set_type_hint (GdkWindow        *window,
2248                           GdkWindowTypeHint hint)
2249 {
2250   g_return_if_fail (GDK_IS_WINDOW (window));
2251
2252   if (GDK_WINDOW_DESTROYED (window))
2253     return;
2254
2255   GDK_NOTE (MISC, g_print ("gdk_window_set_type_hint: 0x%x: %d\n",
2256                GDK_WINDOW_DFB_ID (window), hint));
2257
2258   ((GdkWindowImplDirectFB *)((GdkWindowObject *)window)->impl)->type_hint = hint;
2259
2260
2261   /* N/A */
2262 }
2263
2264 GdkWindowTypeHint
2265 gdk_window_get_type_hint (GdkWindow *window)
2266 {
2267   g_return_val_if_fail (GDK_IS_WINDOW (window), GDK_WINDOW_TYPE_HINT_NORMAL);
2268
2269   if (GDK_WINDOW_DESTROYED (window))
2270     return GDK_WINDOW_TYPE_HINT_NORMAL;
2271
2272   return GDK_WINDOW_IMPL_DIRECTFB (((GdkWindowObject *) window)->impl)->type_hint;
2273 }
2274
2275 void
2276 gdk_window_set_modal_hint (GdkWindow *window,
2277                            gboolean   modal)
2278 {
2279   GdkWindowImplDirectFB *impl;
2280
2281   g_return_if_fail (GDK_IS_WINDOW (window));
2282
2283   if (GDK_WINDOW_DESTROYED (window))
2284     return;
2285
2286   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
2287
2288   if (impl->window)
2289     {
2290       impl->window->SetStackingClass (impl->window,
2291                                       modal ? DWSC_UPPER : DWSC_MIDDLE);
2292     }
2293 }
2294
2295 void
2296 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
2297                                   gboolean   skips_taskbar)
2298 {
2299   g_return_if_fail (GDK_IS_WINDOW (window));
2300 }
2301
2302 void
2303 gdk_window_set_skip_pager_hint (GdkWindow *window,
2304                                 gboolean   skips_pager)
2305 {
2306   g_return_if_fail (GDK_IS_WINDOW (window));
2307 }
2308
2309
2310 void
2311 gdk_window_set_group (GdkWindow *window,
2312                       GdkWindow *leader)
2313 {
2314   g_return_if_fail (GDK_IS_WINDOW (window));
2315   g_return_if_fail (GDK_IS_WINDOW (leader));
2316  g_warning(" DirectFb set_group groups not supported \n");
2317
2318   if (GDK_WINDOW_DESTROYED (window))
2319     return;
2320
2321   /* N/A */
2322 }
2323
2324 GdkWindow * gdk_window_get_group (GdkWindow *window)
2325 {
2326  g_warning(" DirectFb get_group groups not supported \n");
2327  return window;
2328 }
2329
2330 void
2331 gdk_fb_window_set_child_handler (GdkWindow             *window,
2332                                  GdkWindowChildChanged  changed,
2333                                  GdkWindowChildGetPos   get_pos,
2334                                  gpointer               user_data)
2335 {
2336   GdkWindowChildHandlerData *data;
2337
2338   g_return_if_fail (GDK_IS_WINDOW (window));
2339
2340   data = g_new (GdkWindowChildHandlerData, 1);
2341   data->changed   = changed;
2342   data->get_pos   = get_pos;
2343   data->user_data = user_data;
2344
2345   g_object_set_data_full (G_OBJECT (window), "gdk-window-child-handler",
2346                           data, (GDestroyNotify) g_free);
2347 }
2348
2349 void
2350 gdk_window_set_decorations (GdkWindow       *window,
2351                             GdkWMDecoration  decorations)
2352 {
2353   GdkWMDecoration *dec;
2354
2355   g_return_if_fail (GDK_IS_WINDOW (window));
2356
2357   dec = g_new (GdkWMDecoration, 1);
2358   *dec = decorations;
2359
2360   g_object_set_data_full (G_OBJECT (window), "gdk-window-decorations",
2361                           dec, (GDestroyNotify) g_free);
2362 }
2363
2364 gboolean
2365 gdk_window_get_decorations (GdkWindow       *window,
2366                             GdkWMDecoration *decorations)
2367 {
2368   GdkWMDecoration *dec;
2369
2370   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2371
2372   dec = g_object_get_data (G_OBJECT (window), "gdk-window-decorations");
2373   if (dec)
2374     {
2375       *decorations = *dec;
2376       return TRUE;
2377     }
2378   return FALSE;
2379 }
2380
2381 void
2382 gdk_window_set_functions (GdkWindow     *window,
2383                           GdkWMFunction  functions)
2384 {
2385   g_return_if_fail (GDK_IS_WINDOW (window));
2386
2387   if (GDK_WINDOW_DESTROYED (window))
2388     return;
2389
2390   /* N/A */
2391   g_message("unimplemented %s", G_GNUC_FUNCTION);
2392 }
2393
2394 void
2395 gdk_window_set_child_shapes (GdkWindow *window)
2396 {
2397 }
2398
2399 void
2400 gdk_window_merge_child_shapes (GdkWindow *window)
2401 {
2402 }
2403
2404 void
2405 gdk_window_set_child_input_shapes (GdkWindow *window)
2406 {
2407 }
2408
2409 void
2410 gdk_window_merge_child_input_shapes (GdkWindow *window)
2411 {
2412 }
2413
2414 gboolean
2415 gdk_window_set_static_gravities (GdkWindow *window,
2416                                  gboolean   use_static)
2417 {
2418   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2419
2420   if (GDK_WINDOW_DESTROYED (window))
2421     return FALSE;
2422
2423   /* N/A */
2424   g_message("unimplemented %s", G_GNUC_FUNCTION);
2425
2426   return FALSE;
2427 }
2428
2429 void
2430 gdk_window_begin_resize_drag (GdkWindow     *window,
2431                               GdkWindowEdge  edge,
2432                               gint           button,
2433                               gint           root_x,
2434                               gint           root_y,
2435                               guint32        timestamp)
2436 {
2437   g_return_if_fail (GDK_IS_WINDOW (window));
2438
2439   if (GDK_WINDOW_DESTROYED (window))
2440     return;
2441
2442   g_message("unimplemented %s", G_GNUC_FUNCTION);
2443 }
2444
2445 void
2446 gdk_window_begin_move_drag (GdkWindow *window,
2447                             gint       button,
2448                             gint       root_x,
2449                             gint       root_y,
2450                             guint32    timestamp)
2451 {
2452   g_return_if_fail (GDK_IS_WINDOW (window));
2453
2454   if (GDK_WINDOW_DESTROYED (window))
2455     return;
2456
2457   g_message("unimplemented %s", G_GNUC_FUNCTION);
2458 }
2459
2460 /**
2461  * gdk_window_get_frame_extents:
2462  * @window: a #GdkWindow
2463  * @rect: rectangle to fill with bounding box of the window frame
2464  *
2465  * Obtains the bounding box of the window, including window manager
2466  * titlebar/borders if any. The frame position is given in root window
2467  * coordinates. To get the position of the window itself (rather than
2468  * the frame) in root window coordinates, use gdk_window_get_origin().
2469  *
2470  **/
2471 void
2472 gdk_window_get_frame_extents (GdkWindow    *window,
2473                               GdkRectangle *rect)
2474 {
2475   GdkWindowObject         *private;
2476   GdkDrawableImplDirectFB *impl;
2477
2478   g_return_if_fail (GDK_IS_WINDOW (window));
2479   g_return_if_fail (rect != NULL);
2480
2481   if (GDK_WINDOW_DESTROYED (window))
2482     return;
2483
2484   private = GDK_WINDOW_OBJECT (window);
2485
2486   while (private->parent && ((GdkWindowObject*) private->parent)->parent)
2487     private = (GdkWindowObject*) private->parent;
2488   if (GDK_WINDOW_DESTROYED (window))
2489     return;
2490
2491   impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
2492
2493   rect->x      = impl->abs_x;
2494   rect->y      = impl->abs_x;
2495   rect->width  = impl->width;
2496   rect->height = impl->height;
2497 }
2498
2499 /*
2500  * Given a directfb window and a subsurface of that window
2501  * create a gdkwindow child wrapper
2502  */
2503 #if (DIRECTFB_MICRO_VERSION > 25)
2504 GdkWindow *gdk_directfb_create_child_window(GdkWindow *parent,
2505                                 IDirectFBSurface *subsurface)
2506 {
2507   GdkWindow             *window;
2508   GdkWindowObject       *private;
2509   GdkWindowObject       *parent_private;
2510   GdkWindowImplDirectFB *impl;
2511   GdkWindowImplDirectFB *parent_impl;
2512   gint x,y,w,h;
2513
2514   g_return_val_if_fail (parent != NULL, NULL);
2515
2516   window = g_object_new (GDK_TYPE_WINDOW, NULL);
2517   private = GDK_WINDOW_OBJECT (window);
2518   parent_private = GDK_WINDOW_OBJECT (parent);
2519   parent_impl = GDK_WINDOW_IMPL_DIRECTFB (parent_private->impl);
2520   private->parent = parent_private;
2521
2522   subsurface->GetPosition(subsurface,&x,&y);
2523   subsurface->GetSize(subsurface,&w,&h);
2524
2525   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
2526   impl->drawable.wrapper = GDK_DRAWABLE (window);
2527
2528   private->x = x;
2529   private->y = y;
2530
2531   _gdk_directfb_calc_abs (window);
2532
2533   impl->drawable.width  = w;
2534   impl->drawable.height = h;
2535   private->window_type = GDK_WINDOW_CHILD;
2536   impl->drawable.surface = subsurface;
2537   impl->drawable.format = parent_impl->drawable.format;
2538   private->depth = parent_private->depth;
2539   gdk_drawable_set_colormap (GDK_DRAWABLE (window),
2540         gdk_drawable_get_colormap (parent));
2541   gdk_window_set_cursor (window, NULL);
2542   parent_private->children = g_list_prepend (parent_private->children,window);
2543   /*we hold a reference count on ourselves */
2544   g_object_ref (window);
2545
2546   return window;
2547
2548 }
2549 #endif
2550
2551 /*
2552  * The wrapping is not perfect since directfb does not give full access
2553  * to the current state of a window event mask etc need to fix dfb
2554  */
2555 GdkWindow *
2556 gdk_window_foreign_new_for_display (GdkDisplay* display,GdkNativeWindow anid)
2557 {
2558     GdkWindow *window = NULL;
2559     GdkWindow              *parent =NULL;
2560     GdkWindowObject       *private =NULL;
2561     GdkWindowObject       *parent_private =NULL;
2562     GdkWindowImplDirectFB *parent_impl =NULL;
2563     GdkWindowImplDirectFB *impl =NULL;
2564     DFBWindowOptions options;
2565     DFBResult        ret;
2566     GdkDisplayDFB * gdkdisplay =  _gdk_display;
2567     IDirectFBWindow *dfbwindow;
2568
2569     window = gdk_window_lookup (anid);
2570
2571     if (window) {
2572         g_object_ref (window);
2573         return window;
2574     }
2575     if( display != NULL )
2576             gdkdisplay = GDK_DISPLAY_DFB(display);
2577
2578     ret = gdkdisplay->layer->GetWindow (gdkdisplay->layer,
2579                     (DFBWindowID)anid,&dfbwindow);
2580
2581     if (ret != DFB_OK) {
2582         DirectFBError ("gdk_window_new: Layer->GetWindow failed", ret);
2583         return NULL;
2584     }
2585
2586     parent = _gdk_parent_root;
2587
2588     if(parent) {
2589         parent_private = GDK_WINDOW_OBJECT (parent);
2590         parent_impl = GDK_WINDOW_IMPL_DIRECTFB (parent_private->impl);
2591     }
2592
2593     window = g_object_new (GDK_TYPE_WINDOW, NULL);
2594     /* we hold a reference count on ourselves */
2595     g_object_ref (window);
2596     private = GDK_WINDOW_OBJECT (window);
2597     private->parent = parent_private;
2598     private->window_type = GDK_WINDOW_TOPLEVEL;
2599     impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
2600
2601     impl->drawable.wrapper = GDK_DRAWABLE (window);
2602     impl->window = dfbwindow;
2603     dfbwindow->GetOptions(dfbwindow,&options);
2604     dfbwindow->GetPosition(dfbwindow,&private->x,&private->y);
2605     dfbwindow->GetSize(dfbwindow,&impl->drawable.width,&impl->drawable.height);
2606
2607
2608     private->input_only = FALSE;
2609
2610     if( dfbwindow->GetSurface (dfbwindow, &impl->drawable.surface) == DFB_UNSUPPORTED ){
2611         private->input_only = TRUE;
2612         impl->drawable.surface = NULL;
2613     }
2614     /*
2615      * Position ourselevs
2616      */
2617     _gdk_directfb_calc_abs (window);
2618
2619     /* We default to all events least surprise to the user
2620      * minus the poll for motion events
2621      */
2622     gdk_window_set_events (window, (GDK_ALL_EVENTS_MASK ^ GDK_POINTER_MOTION_HINT_MASK));
2623
2624     if (impl->drawable.surface)
2625     {
2626       impl->drawable.surface->GetPixelFormat (impl->drawable.surface,
2627                                               &impl->drawable.format);
2628
2629           private->depth = DFB_BITS_PER_PIXEL(impl->drawable.format);
2630       if( parent )
2631         gdk_drawable_set_colormap (GDK_DRAWABLE (window), gdk_drawable_get_colormap (parent));
2632       else
2633         gdk_drawable_set_colormap (GDK_DRAWABLE (window), gdk_colormap_get_system());
2634     }
2635
2636     //can  be null for the soft cursor window itself when
2637     //running a gtk directfb wm
2638     if( gdk_display_get_default() != NULL ) {
2639         gdk_window_set_cursor (window,NULL);
2640     }
2641
2642     if (parent_private)
2643         parent_private->children = g_list_prepend (parent_private->children,
2644                                                window);
2645     impl->dfb_id = (DFBWindowID)anid;
2646     gdk_directfb_window_id_table_insert (impl->dfb_id, window);
2647     gdk_directfb_event_windows_add (window);
2648
2649     return window;
2650 }
2651
2652 GdkWindow *
2653 gdk_window_lookup_for_display (GdkDisplay *display,GdkNativeWindow anid)
2654 {
2655   return gdk_directfb_window_id_table_lookup ((DFBWindowID) anid);
2656 }
2657
2658 GdkWindow *
2659 gdk_window_lookup (GdkNativeWindow anid)
2660 {
2661   return gdk_directfb_window_id_table_lookup ((DFBWindowID) anid);
2662 }
2663
2664 IDirectFBWindow *gdk_directfb_window_lookup(GdkWindow *window )
2665 {
2666   GdkWindowObject       *private;
2667   GdkWindowImplDirectFB *impl;
2668   g_return_val_if_fail (GDK_IS_WINDOW (window),NULL);
2669   private = GDK_WINDOW_OBJECT (window);
2670   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
2671   return impl->window;
2672 }
2673
2674 IDirectFBSurface *gdk_directfb_surface_lookup(GdkWindow *window)
2675 {
2676   GdkWindowObject       *private;
2677   GdkWindowImplDirectFB *impl;
2678   g_return_val_if_fail (GDK_IS_WINDOW (window),NULL);
2679   private = GDK_WINDOW_OBJECT (window);
2680   impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
2681   return impl->drawable.surface;
2682 }
2683
2684 void
2685 gdk_window_fullscreen (GdkWindow *window)
2686 {
2687   g_return_if_fail (GDK_IS_WINDOW (window));
2688   g_warning ("gdk_window_fullscreen() not implemented.\n");
2689 }
2690
2691 void
2692 gdk_window_unfullscreen (GdkWindow *window)
2693 {
2694   g_return_if_fail (GDK_IS_WINDOW (window));
2695   /* g_warning ("gdk_window_unfullscreen() not implemented.\n");*/
2696 }
2697
2698 void
2699 gdk_window_set_keep_above (GdkWindow *window, gboolean setting)
2700 {
2701   g_return_if_fail (GDK_IS_WINDOW (window));
2702   static gboolean first_call = TRUE;
2703   if (first_call) {
2704   g_warning ("gdk_window_set_keep_above() not implemented.\n");
2705         first_call=FALSE;
2706   }
2707
2708 }
2709
2710 void
2711 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
2712 {
2713   g_return_if_fail (GDK_IS_WINDOW (window));
2714   static gboolean first_call = TRUE;
2715   if (first_call) {
2716   g_warning ("gdk_window_set_keep_below() not implemented.\n");
2717   first_call=FALSE;
2718   }
2719
2720 }
2721
2722 void
2723 gdk_window_enable_synchronized_configure (GdkWindow *window)
2724 {
2725 }
2726
2727 void
2728 gdk_window_configure_finished (GdkWindow *window)
2729 {
2730 }
2731
2732 void
2733 gdk_display_warp_pointer (GdkDisplay *display,
2734                           GdkScreen  *screen,
2735                           gint        x,
2736                           gint        y)
2737 {
2738   g_warning ("gdk_display_warp_pointer() not implemented.\n");
2739 }
2740
2741 void
2742 gdk_window_set_urgency_hint (GdkWindow *window,
2743                              gboolean   urgent)
2744 {
2745   g_return_if_fail (GDK_IS_WINDOW (window));
2746   g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD);
2747
2748   if (GDK_WINDOW_DESTROYED (window))
2749     return;
2750
2751   g_warning ("gdk_window_set_urgency_hint() not implemented.\n");
2752
2753 }
2754
2755 static void
2756 gdk_window_impl_directfb_invalidate_maybe_recurse (GdkPaintable *paintable,
2757                          GdkRegion    *region,
2758                          gboolean    (*child_func) (GdkWindow *, gpointer),
2759                          gpointer      user_data)
2760 {
2761   GdkWindow *window;
2762   GdkWindowObject *private;
2763   GdkWindowImplDirectFB *wimpl;
2764   GdkDrawableImplDirectFB *impl;
2765
2766   wimpl = GDK_WINDOW_IMPL_DIRECTFB (paintable);
2767   impl = (GdkDrawableImplDirectFB *)wimpl;
2768   window = wimpl->gdkWindow;
2769   private = (GdkWindowObject *)window;
2770
2771   GdkRegion *visible_region;
2772   GList *tmp_list;
2773
2774   g_return_if_fail (window != NULL);
2775   g_return_if_fail (GDK_IS_WINDOW (window));
2776
2777   if (GDK_WINDOW_DESTROYED (window))
2778     return;
2779
2780   if (private->input_only || !GDK_WINDOW_IS_MAPPED (window))
2781     return;
2782
2783   visible_region = gdk_drawable_get_visible_region (window);
2784   gdk_region_intersect (visible_region, region);
2785
2786   tmp_list = private->children;
2787   while (tmp_list)
2788     {
2789       GdkWindowObject *child = tmp_list->data;
2790
2791       if (!child->input_only)
2792         {
2793           GdkRegion *child_region;
2794           GdkRectangle child_rect;
2795
2796           gdk_window_get_position ((GdkWindow *)child,
2797                                    &child_rect.x, &child_rect.y);
2798           gdk_drawable_get_size ((GdkDrawable *)child,
2799                                  &child_rect.width, &child_rect.height);
2800
2801           child_region = gdk_region_rectangle (&child_rect);
2802
2803           /* remove child area from the invalid area of the parent */
2804           if (GDK_WINDOW_IS_MAPPED (child) && !child->shaped)
2805             gdk_region_subtract (visible_region, child_region);
2806
2807           if (child_func && (*child_func) ((GdkWindow *)child, user_data))
2808             {
2809               gdk_region_offset (region, - child_rect.x, - child_rect.y);
2810               gdk_region_offset (child_region, - child_rect.x, - child_rect.y);
2811               gdk_region_intersect (child_region, region);
2812
2813               gdk_window_invalidate_maybe_recurse ((GdkWindow *)child,
2814                                                    child_region, child_func, user_data);
2815
2816               gdk_region_offset (region, child_rect.x, child_rect.y);
2817             }
2818
2819           gdk_region_destroy (child_region);
2820         }
2821
2822       tmp_list = tmp_list->next;
2823     }
2824
2825   if (!gdk_region_empty (visible_region))
2826     {
2827
2828       if (private->update_area)
2829         {
2830           gdk_region_union (private->update_area, visible_region);
2831         }
2832       else
2833         {
2834           update_windows = g_slist_prepend (update_windows, window);
2835           private->update_area = gdk_region_copy (visible_region);
2836           gdk_window_schedule_update (window);
2837         }
2838     }
2839     gdk_region_destroy (visible_region);
2840 }
2841
2842
2843 static void
2844 gdk_window_impl_directfb_process_updates (GdkPaintable *paintable,
2845                     gboolean      update_children)
2846 {
2847   GdkWindow *window;
2848   GdkWindowObject *private;
2849   GdkWindowImplDirectFB *wimpl;
2850   GdkDrawableImplDirectFB *impl;
2851
2852   wimpl = GDK_WINDOW_IMPL_DIRECTFB (paintable);
2853   impl = (GdkDrawableImplDirectFB *)wimpl;
2854   window = wimpl->gdkWindow;
2855   private = (GdkWindowObject *)window;
2856   gboolean save_region = FALSE;
2857
2858   /* If an update got queued during update processing, we can get a
2859    * window in the update queue that has an empty update_area.
2860    * just ignore it.
2861    */
2862   if (private->update_area)
2863     {
2864       GdkRegion *update_area = private->update_area;
2865       private->update_area = NULL;
2866
2867       if (_gdk_event_func && gdk_window_is_viewable (window))
2868         {
2869           GdkRectangle window_rect;
2870           GdkRegion *expose_region;
2871           GdkRegion *window_region;
2872           gint width, height;
2873           save_region = _gdk_windowing_window_queue_antiexpose (window, update_area);
2874
2875           if (save_region)
2876             expose_region = gdk_region_copy (update_area);
2877           else
2878             expose_region = update_area;
2879
2880           gdk_drawable_get_size (GDK_DRAWABLE (private), &width, &height);
2881
2882           window_rect.x = 0;
2883           window_rect.y = 0;
2884           window_rect.width = width;
2885           window_rect.height = height;
2886
2887           window_region = gdk_region_rectangle (&window_rect);
2888           gdk_region_intersect (expose_region,
2889                                 window_region);
2890           gdk_region_destroy (window_region);
2891
2892           if (!gdk_region_empty (expose_region) &&
2893               (private->event_mask & GDK_EXPOSURE_MASK))
2894             {
2895               GdkEvent event;
2896
2897               event.expose.type = GDK_EXPOSE;
2898               event.expose.window = g_object_ref (window);
2899               event.expose.send_event = FALSE;
2900               event.expose.count = 0;
2901               event.expose.region = expose_region;
2902               gdk_region_get_clipbox (expose_region, &event.expose.area);
2903               (*_gdk_event_func) (&event, _gdk_event_data);
2904
2905               g_object_unref (window);
2906             }
2907
2908           if (expose_region != update_area)
2909             gdk_region_destroy (expose_region);
2910         }
2911       if (!save_region)
2912         gdk_region_destroy (update_area);
2913     }
2914 }
2915
2916
2917 static void
2918 gdk_window_impl_directfb_begin_paint_region (GdkPaintable *paintable,
2919                                            GdkRegion    *region)
2920 {
2921   GdkDrawableImplDirectFB *impl;
2922   GdkWindowImplDirectFB *wimpl;
2923   gint                     i;
2924
2925
2926   g_assert (region != NULL );
2927   wimpl = GDK_WINDOW_IMPL_DIRECTFB (paintable);
2928   impl = (GdkDrawableImplDirectFB *)wimpl;
2929   impl->buffered = TRUE;
2930   impl->paint_depth++;
2931
2932   if (!region)
2933     return;
2934
2935   if (impl->paint_region)
2936     gdk_region_union (impl->paint_region, region);
2937   else
2938     impl->paint_region = gdk_region_copy (region);
2939
2940   for (i = 0; i < region->numRects; i++)
2941     {
2942       GdkRegionBox *box = &region->rects[i];
2943
2944       _gdk_windowing_window_clear_area (GDK_WINDOW(wimpl->gdkWindow),
2945                                         box->x1,
2946                                         box->y1,
2947                                         box->x2 - box->x1,
2948                                         box->y2 - box->y1);
2949
2950     }
2951 }
2952
2953 static void
2954 gdk_window_impl_directfb_end_paint (GdkPaintable *paintable)
2955 {
2956   GdkDrawableImplDirectFB *impl;
2957
2958   impl = GDK_DRAWABLE_IMPL_DIRECTFB (paintable);
2959
2960   g_return_if_fail (impl->paint_depth > 0);
2961
2962   impl->paint_depth--;
2963
2964   if (impl->paint_depth == 0)
2965     {
2966       impl->buffered = FALSE;
2967
2968       if (impl->paint_region)
2969         {
2970           DFBRegion reg = { impl->paint_region->extents.x1,
2971                             impl->paint_region->extents.y1,
2972                             impl->paint_region->extents.x2 ,
2973                             impl->paint_region->extents.y2 };
2974
2975           impl->surface->Flip(impl->surface, &reg,0);
2976           gdk_region_destroy (impl->paint_region);
2977           impl->paint_region = NULL;
2978         }
2979     }
2980 }
2981
2982
2983 static void
2984 gdk_window_impl_directfb_paintable_init (GdkPaintableIface *iface)
2985 {
2986   iface->begin_paint_region = gdk_window_impl_directfb_begin_paint_region;
2987   iface->end_paint = gdk_window_impl_directfb_end_paint;
2988
2989   iface->invalidate_maybe_recurse = gdk_window_impl_directfb_invalidate_maybe_recurse;
2990   iface->process_updates = gdk_window_impl_directfb_process_updates;
2991 }
2992
2993 void
2994 gdk_window_beep (GdkWindow *window)
2995 {
2996   gdk_display_beep (GDK_WINDOW_DISPLAY (window));
2997 }
2998
2999 #define __GDK_WINDOW_X11_C__
3000 #include "gdkaliasdef.c"
3001