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