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

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