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