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

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <config.h>
  28 #include "gdk.h"
  29
  30 #include "gdkwindow.h"
  31 #include "gdkinputprivate.h"
  32 #include "gdkprivate-fb.h"
  33 #include "gdkinternals.h"
  34
  35 #include <limits.h>
  36
  37 /* Global variables: */
  38 static GdkWindow *gdk_fb_window_containing_pointer = NULL;
  39 static GdkWindow *gdk_fb_focused_window = NULL;
  40 static gpointer parent_class = NULL;
  41
  42 static void recompute_drawable (GdkDrawable *drawable);
  43 static void gdk_fb_window_raise (GdkWindow *window);
  44 static GdkRegion* gdk_window_fb_get_visible_region (GdkDrawable *drawable);
  45
  46 typedef struct
  47 {
  48   GdkWindowChildChanged  changed;
  49   GdkWindowChildGetPos   get_pos;
  50   gpointer               user_data;
  51 }  GdkWindowChildHandlerData;
  52
  53 static void
  54 g_free_2nd (gpointer a, gpointer b, gpointer data)
  55 {
  56   g_free (b);
  57 }
  58
  59 static void
  60 gdk_window_impl_fb_finalize (GObject *object)
  61 {
  62   GdkWindowFBData *fbd = GDK_WINDOW_FBDATA (object);
  63
  64   if (GDK_WINDOW_IS_MAPPED (fbd->drawable_data.wrapper))
  65     gdk_window_hide (fbd->drawable_data.wrapper);
  66
  67   if (fbd->cursor)
  68     gdk_cursor_unref (fbd->cursor);
  69
  70   if (fbd->properties)
  71     {
  72       g_hash_table_foreach (fbd->properties, g_free_2nd, NULL);
  73       g_hash_table_destroy (fbd->properties);
  74     }
  75
  76   G_OBJECT_CLASS (parent_class)->finalize (object);
  77 }
  78
  79 static void
  80 gdk_window_impl_fb_class_init (GdkWindowFBClass *klass)
  81 {
  82   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  83   GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
  84
  85   parent_class = g_type_class_peek_parent (klass);
  86
  87   object_class->finalize = gdk_window_impl_fb_finalize;
  88
  89   /* Visible and clip regions are the same */
  90   drawable_class->get_clip_region = gdk_window_fb_get_visible_region;
  91   drawable_class->get_visible_region = gdk_window_fb_get_visible_region;
  92 }
  93
  94 static void
  95 gdk_window_impl_fb_init (GdkWindowFBData *impl)
  96 {
  97   impl->drawable_data.depth = gdk_display->modeinfo.bits_per_pixel;
  98   impl->drawable_data.colormap = gdk_colormap_get_system ();
  99   impl->shape = NULL;
 100 }
 101
 102 GType
 103 _gdk_window_impl_get_type (void)
 104 {
 105   static GType object_type = 0;
 106
 107   if (!object_type)
 108     {
 109       static const GTypeInfo object_info =
 110       {
 111         sizeof (GdkWindowFBClass),
 112         (GBaseInitFunc) NULL,
 113         (GBaseFinalizeFunc) NULL,
 114         (GClassInitFunc) gdk_window_impl_fb_class_init,
 115         NULL,           /* class_finalize */
 116         NULL,           /* class_data */
 117         sizeof (GdkWindowFBData),
 118         0,              /* n_preallocs */
 119         (GInstanceInitFunc) gdk_window_impl_fb_init,
 120       };
 121
 122       object_type = g_type_register_static (gdk_drawable_impl_fb_get_type(),
 123                                             "GdkWindowFB",
 124                                             &object_info,
 125                                             0);
 126     }
 127
 128   return object_type;
 129 }
 130
 131 void
 132 _gdk_windowing_window_init (void)
 133 {
 134   GdkWindowAttr attr;
 135
 136   GdkCursor *cursor;
 137   GdkWindowObject *private;
 138
 139   attr.width = gdk_screen_width ();
 140   attr.height = gdk_screen_height ();
 141   attr.window_type = GDK_WINDOW_ROOT;
 142   attr.cursor = NULL;
 143   attr.event_mask = GDK_EXPOSURE_MASK;
 144   attr.wclass = GDK_INPUT_OUTPUT;
 145   _gdk_parent_root = gdk_window_new (NULL, &attr, GDK_WA_CURSOR);
 146   private = (GdkWindowObject *)_gdk_parent_root;
 147
 148   private->state = 0;
 149
 150   GDK_DRAWABLE_IMPL_FBDATA (_gdk_parent_root)->lim_x = attr.width;
 151   GDK_DRAWABLE_IMPL_FBDATA (_gdk_parent_root)->lim_y = attr.height;
 152
 153   _gdk_fb_screen_gc = gdk_gc_new (_gdk_parent_root);
 154
 155   gdk_fb_drawable_clear (_gdk_parent_root);
 156
 157   /* Must be done after root is created, since gdk_cursor_new()
 158    * references _gdk_parent_root.
 159    */
 160   cursor = gdk_cursor_new (GDK_LEFT_PTR);
 161   gdk_window_set_cursor (_gdk_parent_root, cursor);
 162 }
 163
 164 GdkWindow*
 165 gdk_window_new (GdkWindow     *parent,
 166                 GdkWindowAttr *attributes,
 167                 gint           attributes_mask)
 168 {
 169   GdkWindow *window;
 170   GdkWindowObject *private;
 171   GdkWindowObject *parent_private;
 172   GdkVisual *visual;
 173   GdkWindowFBData *impl;
 174
 175   int x, y, depth;
 176
 177   g_return_val_if_fail (attributes != NULL, NULL);
 178
 179   if (!parent ||
 180       (attributes->window_type != GDK_WINDOW_CHILD &&
 181        attributes->window_type != GDK_WINDOW_TEMP))
 182     parent = _gdk_parent_root;
 183
 184   parent_private = (GdkWindowObject*) parent;
 185
 186   window = (GdkWindow *)g_object_new (GDK_TYPE_WINDOW, NULL);
 187   private = (GdkWindowObject *)window;
 188
 189   private->parent = parent_private;
 190
 191   private->accept_focus = TRUE;
 192   private->focus_on_map = TRUE;
 193
 194   if (attributes_mask & GDK_WA_X)
 195     x = attributes->x;
 196   else
 197     x = 0;
 198
 199   if (attributes_mask & GDK_WA_Y)
 200     y = attributes->y;
 201   else
 202     y = 0;
 203
 204   gdk_window_set_events (window, attributes->event_mask);
 205
 206   if (attributes_mask & GDK_WA_VISUAL)
 207     visual = attributes->visual;
 208   else
 209     visual = gdk_visual_get_system ();
 210
 211   impl = (GdkWindowFBData *)private->impl;
 212   impl->drawable_data.wrapper = window;
 213   private->x = x;
 214   private->y = y;
 215   impl->drawable_data.width = (attributes->width > 1) ? (attributes->width) : (1);
 216   impl->drawable_data.height = (attributes->height > 1) ? (attributes->height) : (1);
 217   private->window_type = impl->drawable_data.window_type = attributes->window_type;
 218   impl->drawable_data.mem = gdk_display->fb_mem;
 219   impl->drawable_data.rowstride = gdk_display->fb_stride;
 220   gdk_window_move_resize (window, x, y,
 221                           impl->drawable_data.width, impl->drawable_data.height);
 222
 223   if (attributes->wclass == GDK_INPUT_OUTPUT)
 224     {
 225       depth = visual->depth;
 226
 227       private->input_only = FALSE;
 228       private->depth = impl->drawable_data.depth;
 229
 230       if ((attributes_mask & GDK_WA_COLORMAP) &&
 231           attributes->colormap)
 232         impl->drawable_data.colormap = attributes->colormap;
 233       else
 234         impl->drawable_data.colormap = gdk_colormap_get_system ();
 235
 236       switch (impl->drawable_data.window_type)
 237         {
 238         case GDK_WINDOW_TOPLEVEL:
 239         case GDK_WINDOW_CHILD:
 240         case GDK_WINDOW_DIALOG:
 241         case GDK_WINDOW_TEMP:
 242         default:
 243           break;
 244
 245         case GDK_WINDOW_ROOT:
 246           if (_gdk_parent_root)
 247             g_error ("cannot make windows of type GDK_WINDOW_ROOT");
 248           break;
 249         case GDK_DRAWABLE_PIXMAP:
 250           g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
 251           break;
 252         }
 253     }
 254   else
 255     {
 256       depth = 0;
 257       private->input_only = TRUE;
 258       impl->drawable_data.colormap = NULL;
 259     }
 260
 261   if (impl->drawable_data.colormap)
 262     gdk_colormap_ref (impl->drawable_data.colormap);
 263
 264   gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
 265                                   (attributes->cursor) :
 266                                   NULL));
 267
 268   if (parent_private)
 269     parent_private->children = g_list_prepend (parent_private->children, window);
 270
 271   return window;
 272 }
 273
 274 /* This function is called when the XWindow is really gone.  */
 275 void
 276 _gdk_windowing_window_destroy (GdkWindow *window,
 277                                gboolean   recursing,
 278                                gboolean   foreign_destroy)
 279 {
 280   GdkWindowObject *private;
 281   GdkRectangle r;
 282
 283   private = (GdkWindowObject*) window;
 284
 285   _gdk_selection_window_destroyed (window);
 286
 287   r.x = private->x;
 288   r.y = private->y;
 289   r.width = GDK_DRAWABLE_IMPL_FBDATA (window)->width;
 290   r.height = GDK_DRAWABLE_IMPL_FBDATA (window)->height;
 291   /* Clear the root window, as it might be visible under
 292      the destroyed window */
 293   gdk_window_clear_area (_gdk_parent_root,
 294                          r.x,
 295                          r.y,
 296                          r.width,
 297                          r.height);
 298   /* Invalidate the rect */
 299   gdk_window_invalidate_rect ((GdkWindow *)private->parent, &r, TRUE);
 300 }
 301
 302 static gboolean
 303 all_parents_shown (GdkWindowObject *private)
 304 {
 305   while (GDK_WINDOW_IS_MAPPED (private))
 306     {
 307       if (private->parent)
 308         private = (GdkWindowObject *)private->parent;
 309       else
 310         return TRUE;
 311     }
 312
 313   return FALSE;
 314 }
 315
 316 static void
 317 send_map_events (GdkWindowObject *private, gboolean is_map)
 318 {
 319   GList *l;
 320   GdkWindow *parent = (GdkWindow *)private->parent;
 321   GdkWindow *event_win;
 322
 323   g_assert (is_map);
 324
 325   if (!GDK_WINDOW_IS_MAPPED (private))
 326     return;
 327
 328   if (is_map)
 329     {
 330       event_win = gdk_fb_other_event_window ((GdkWindow *)private, GDK_MAP);
 331       if (event_win)
 332         gdk_event_make (event_win, GDK_MAP, TRUE);
 333     }
 334   if (private->input_only)
 335     return;
 336
 337   if (!parent)
 338     parent = (GdkWindow *)private;
 339
 340   if (((GDK_DRAWABLE_IMPL_FBDATA (private)->abs_x > GDK_DRAWABLE_IMPL_FBDATA (parent)->lim_x) ||
 341        (GDK_DRAWABLE_IMPL_FBDATA (private)->abs_y > GDK_DRAWABLE_IMPL_FBDATA (parent)->lim_y) ||
 342        (GDK_DRAWABLE_IMPL_FBDATA (private)->lim_x < GDK_DRAWABLE_IMPL_FBDATA (parent)->llim_x) ||
 343        (GDK_DRAWABLE_IMPL_FBDATA (private)->lim_y < GDK_DRAWABLE_IMPL_FBDATA (parent)->llim_y)))
 344      return;
 345
 346   if (is_map)
 347     gdk_window_clear ((GdkWindow *)private);
 348
 349   for (l = private->children; l; l = l->next)
 350     send_map_events (l->data, is_map);
 351 }
 352
 353 /* Cut & paste versions of the stuff in gdkwindow.c, with the addition of clearing the newly exposed region. */
 354 void
 355 gdk_window_invalidate_region_clear(GdkWindow *window,
 356                                    GdkRegion *region)
 357 {
 358   int i;
 359   GdkWindowObject *private = GDK_WINDOW_P (window);
 360
 361   if (private->input_only || !GDK_WINDOW_IS_MAPPED (private))
 362     return;
 363
 364   if (private->bg_pixmap != GDK_NO_BG)
 365     for (i = 0; i < region->numRects; i++)
 366       gdk_window_clear_area (window,
 367                              region->rects[i].x1,
 368                              region->rects[i].y1,
 369                              region->rects[i].x2 - region->rects[i].x1,
 370                              region->rects[i].y2 - region->rects[i].y1);
 371
 372   gdk_window_invalidate_region (window, region, FALSE);
 373
 374   {
 375     GList *tmp_list;
 376     GdkRectangle child_rect;
 377     GdkRegion *child_region;
 378
 379     tmp_list = private->children;
 380     while (tmp_list)
 381       {
 382         GdkWindowObject *child = tmp_list->data;
 383         tmp_list = tmp_list->next;
 384
 385         if (!child->input_only)
 386           {
 387             gint width, height;
 388
 389             gdk_drawable_get_size (GDK_DRAWABLE (child),
 390                                    &width, &height);
 391
 392             child_rect.x = child->x;
 393             child_rect.y = child->y;
 394             child_rect.width = width;
 395             child_rect.height = height;
 396
 397             child_region = gdk_region_rectangle (&child_rect);
 398             gdk_region_intersect (child_region, region);
 399
 400             if (!gdk_region_empty (child_region))
 401               {
 402                 gdk_region_offset (child_region, - child_rect.x, - child_rect.y);
 403                 gdk_window_invalidate_region_clear ((GdkWindow *)child, child_region);
 404               }
 405
 406             gdk_region_destroy (child_region);
 407           }
 408       }
 409   }
 410 }
 411
 412 void
 413 gdk_window_invalidate_rect_clear (GdkWindow *window,
 414                                   GdkRectangle *rect)
 415 {
 416   GdkWindowObject *private = GDK_WINDOW_P (window);
 417
 418   if (private->input_only || !GDK_WINDOW_IS_MAPPED (private))
 419     return;
 420
 421   if (GDK_WINDOW_P (window)->bg_pixmap != GDK_NO_BG)
 422     gdk_window_clear_area (window, rect->x, rect->y, rect->width, rect->height);
 423   gdk_window_invalidate_rect (window, rect, FALSE);
 424
 425   {
 426     GList *tmp_list;
 427     GdkRectangle child_rect, new_rect;
 428
 429     tmp_list = private->children;
 430     while (tmp_list)
 431       {
 432         GdkWindowObject *child = tmp_list->data;
 433         tmp_list = tmp_list->next;
 434
 435         if (!child->input_only)
 436           {
 437             gint width, height;
 438
 439             width = GDK_DRAWABLE_IMPL_FBDATA (child)->width;
 440             height = GDK_DRAWABLE_IMPL_FBDATA (child)->height;
 441
 442             child_rect.x = child->x;
 443             child_rect.y = child->y;
 444             child_rect.width = width;
 445             child_rect.height = height;
 446
 447             if (gdk_rectangle_intersect (rect, &child_rect, &new_rect))
 448               {
 449                 new_rect.x -= child_rect.x;
 450                 new_rect.y -= child_rect.y;
 451
 452                 gdk_window_invalidate_rect_clear ((GdkWindow *)child, &new_rect);
 453               }
 454           }
 455       }
 456   }
 457 }
 458
 459 void
 460 gdk_fb_redraw_all (void)
 461 {
 462   GdkRectangle r;
 463   r.x = r.y = 0;
 464   r.width = GDK_DRAWABLE_IMPL_FBDATA (_gdk_parent_root)->width;
 465   r.height = GDK_DRAWABLE_IMPL_FBDATA (_gdk_parent_root)->height;
 466   gdk_window_invalidate_rect_clear (_gdk_parent_root, &r);
 467   gdk_window_process_all_updates ();
 468 }
 469
 470
 471 /* Focus follows pointer */
 472 static GdkWindow *
 473 gdk_fb_window_find_toplevel (GdkWindow *window)
 474 {
 475   GdkWindowObject *priv = (GdkWindowObject *)window;
 476   while (priv != (GdkWindowObject *)_gdk_parent_root)
 477     {
 478       if ((priv->parent == (GdkWindowObject *)_gdk_parent_root) && GDK_WINDOW_IS_MAPPED (priv))
 479         return (GdkWindow *)priv;
 480       priv = priv->parent;
 481     }
 482
 483   return _gdk_parent_root;
 484 }
 485
 486 GdkWindow *
 487 gdk_fb_window_find_focus (void)
 488 {
 489   if (_gdk_fb_keyboard_grab_window)
 490     return _gdk_fb_keyboard_grab_window;
 491
 492   if (!gdk_fb_focused_window)
 493     gdk_fb_focused_window = gdk_window_ref (_gdk_parent_root);
 494
 495   return gdk_fb_focused_window;
 496 }
 497
 498
 499 static void
 500 gdk_fb_change_focus (GdkWindow *new_focus_window)
 501 {
 502   GdkEventFocus *event;
 503   GdkWindow *old_win, *new_win;
 504   GdkWindow *event_win;
 505
 506   /* No focus changes while the pointer is grabbed */
 507   if (_gdk_fb_pointer_grab_window)
 508     return;
 509
 510   old_win = gdk_fb_focused_window;
 511   new_win = gdk_fb_window_find_toplevel (new_focus_window);
 512
 513   if (old_win != new_win)
 514     {
 515       if (old_win)
 516         {
 517           event_win = gdk_fb_keyboard_event_window (old_win, GDK_FOCUS_CHANGE);
 518           if (event_win)
 519             {
 520               event = (GdkEventFocus *)gdk_event_make (event_win, GDK_FOCUS_CHANGE, TRUE);
 521               event->in = FALSE;
 522             }
 523         }
 524       event_win = gdk_fb_keyboard_event_window (new_win, GDK_FOCUS_CHANGE);
 525       if (event_win)
 526         {
 527           event = (GdkEventFocus *)gdk_event_make (event_win, GDK_FOCUS_CHANGE, TRUE);
 528           event->in = TRUE;
 529         }
 530
 531       if (gdk_fb_focused_window)
 532         gdk_window_unref (gdk_fb_focused_window);
 533       gdk_fb_focused_window = gdk_window_ref (new_win);
 534     }
 535 }
 536
 537 static GdkWindow *
 538 gdk_fb_find_common_ancestor (GdkWindow *win1,
 539                              GdkWindow *win2)
 540 {
 541   GdkWindowObject *tmp;
 542   GList *path1 = NULL, *path2 = NULL;
 543   GList *list1, *list2;
 544
 545   tmp = GDK_WINDOW_OBJECT (win1);
 546   while (tmp)
 547     {
 548       path1 = g_list_prepend(path1, tmp);
 549       tmp = tmp->parent;
 550     }
 551
 552   tmp = GDK_WINDOW_OBJECT (win2);
 553   while (tmp)
 554     {
 555       path2 = g_list_prepend(path2, tmp);
 556       tmp = tmp->parent;
 557     }
 558
 559   list1 = path1;
 560   list2 = path2;
 561   tmp = NULL;
 562   while (list1 && list2 && (list1->data == list2->data))
 563     {
 564       tmp = (GdkWindowObject *)list1->data;
 565       list1 = g_list_next (list1);
 566       list2 = g_list_next (list2);
 567     }
 568   g_list_free (path1);
 569   g_list_free (path2);
 570   return GDK_WINDOW (tmp);
 571 }
 572
 573 void
 574 gdk_fb_window_send_crossing_events (GdkWindow *src,
 575                                     GdkWindow *dest,
 576                                     GdkCrossingMode mode)
 577 {
 578   GdkWindow *c;
 579   GdkWindow *win, *last, *next;
 580   GdkEvent *event;
 581   gint x, y, x_int, y_int;
 582   GdkModifierType my_mask;
 583   GList *path, *list;
 584   gboolean non_linear;
 585   GdkWindow *a;
 586   GdkWindow *b;
 587   GdkWindow *event_win;
 588
 589   if ((mode == GDK_CROSSING_NORMAL) &&
 590       (dest == gdk_fb_window_containing_pointer))
 591     return;
 592
 593   if (gdk_fb_window_containing_pointer == NULL)
 594     gdk_fb_window_containing_pointer = gdk_window_ref (_gdk_parent_root);
 595
 596   if (src)
 597     a = src;
 598   else
 599     a = gdk_fb_window_containing_pointer;
 600   b = dest;
 601
 602   if (a==b)
 603     return;
 604
 605   /* gdk_fb_window_containing_pointer might have been destroyed.
 606    * The refcount we hold on it should keep it, but it's parents
 607    * might have died.
 608    */
 609   if (GDK_WINDOW_DESTROYED (a))
 610     a = _gdk_parent_root;
 611
 612   gdk_fb_mouse_get_info (&x, &y, &my_mask);
 613
 614   c = gdk_fb_find_common_ancestor (a, b);
 615
 616   non_linear = (c != a) && (c != b);
 617
 618   event_win = gdk_fb_pointer_event_window (a, GDK_LEAVE_NOTIFY);
 619   if (event_win)
 620     {
 621       event = gdk_event_make (event_win, GDK_LEAVE_NOTIFY, TRUE);
 622       event->crossing.subwindow = NULL;
 623       gdk_window_get_root_origin (a, &x_int, &y_int);
 624       event->crossing.x = x - x_int;
 625       event->crossing.y = y - y_int;
 626       event->crossing.x_root = x;
 627       event->crossing.y_root = y;
 628       event->crossing.mode = mode;
 629       if (non_linear)
 630         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
 631       else if (c==a)
 632         event->crossing.detail = GDK_NOTIFY_INFERIOR;
 633       else
 634         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 635       event->crossing.focus = FALSE;
 636       event->crossing.state = my_mask;
 637     }
 638
 639   /* Traverse up from a to (excluding) c */
 640   if (c != a)
 641     {
 642       last = a;
 643       win = GDK_WINDOW (GDK_WINDOW_OBJECT (a)->parent);
 644       while (win != c)
 645         {
 646           event_win = gdk_fb_pointer_event_window (win, GDK_LEAVE_NOTIFY);
 647           if (event_win)
 648             {
 649               event = gdk_event_make (event_win, GDK_LEAVE_NOTIFY, TRUE);
 650               event->crossing.subwindow = gdk_window_ref (last);
 651               gdk_window_get_root_origin (win, &x_int, &y_int);
 652               event->crossing.x = x - x_int;
 653               event->crossing.y = y - y_int;
 654               event->crossing.x_root = x;
 655               event->crossing.y_root = y;
 656               event->crossing.mode = mode;
 657               if (non_linear)
 658                 event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
 659               else
 660                 event->crossing.detail = GDK_NOTIFY_VIRTUAL;
 661               event->crossing.focus = FALSE;
 662               event->crossing.state = my_mask;
 663             }
 664           last = win;
 665           win = GDK_WINDOW (GDK_WINDOW_OBJECT (win)->parent);
 666         }
 667     }
 668
 669   /* Traverse down from c to b */
 670   if (c != b)
 671     {
 672       path = NULL;
 673       win = GDK_WINDOW( GDK_WINDOW_OBJECT (b)->parent);
 674       while (win != c)
 675         {
 676           path = g_list_prepend (path, win);
 677           win = GDK_WINDOW( GDK_WINDOW_OBJECT (win)->parent);
 678         }
 679
 680       list = path;
 681       while (list)
 682         {
 683           win = (GdkWindow *)list->data;
 684           list = g_list_next (list);
 685           if (list)
 686             next = (GdkWindow *)list->data;
 687           else
 688             next = b;
 689
 690           event_win = gdk_fb_pointer_event_window (win, GDK_ENTER_NOTIFY);
 691           if (event_win)
 692             {
 693               event = gdk_event_make (event_win, GDK_ENTER_NOTIFY, TRUE);
 694               event->crossing.subwindow = gdk_window_ref (next);
 695               gdk_window_get_root_origin (win, &x_int, &y_int);
 696               event->crossing.x = x - x_int;
 697               event->crossing.y = y - y_int;
 698               event->crossing.x_root = x;
 699               event->crossing.y_root = y;
 700               event->crossing.mode = mode;
 701               if (non_linear)
 702                 event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
 703               else
 704                 event->crossing.detail = GDK_NOTIFY_VIRTUAL;
 705               event->crossing.focus = FALSE;
 706               event->crossing.state = my_mask;
 707             }
 708         }
 709       g_list_free (path);
 710     }
 711
 712   event_win = gdk_fb_pointer_event_window (b, GDK_ENTER_NOTIFY);
 713   if (event_win)
 714     {
 715       event = gdk_event_make (event_win, GDK_ENTER_NOTIFY, TRUE);
 716       event->crossing.subwindow = NULL;
 717       gdk_window_get_root_origin (b, &x_int, &y_int);
 718       event->crossing.x = x - x_int;
 719       event->crossing.y = y - y_int;
 720       event->crossing.x_root = x;
 721       event->crossing.y_root = y;
 722       event->crossing.mode = mode;
 723       if (non_linear)
 724         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
 725       else if (c==a)
 726         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 727       else
 728         event->crossing.detail = GDK_NOTIFY_INFERIOR;
 729       event->crossing.focus = FALSE;
 730       event->crossing.state = my_mask;
 731     }
 732
 733   if (mode != GDK_CROSSING_GRAB)
 734     {
 735       gdk_fb_change_focus (b);
 736       if (b != gdk_fb_window_containing_pointer)
 737         {
 738           gdk_window_unref (gdk_fb_window_containing_pointer);
 739           gdk_fb_window_containing_pointer = gdk_window_ref (b);
 740         }
 741     }
 742 }
 743
 744 static void
 745 show_window_internal (GdkWindow *window,
 746                       gboolean   raise)
 747 {
 748   GdkWindowObject *private;
 749   GdkWindow *mousewin;
 750
 751   g_return_if_fail (window != NULL);
 752
 753   private = (GdkWindowObject*) window;
 754
 755   if (!private->destroyed && !GDK_WINDOW_IS_MAPPED (private))
 756     {
 757       private->state = 0;
 758
 759       if (raise)
 760         gdk_fb_window_raise (window);
 761
 762       if (all_parents_shown ((GdkWindowObject *)private->parent))
 763         {
 764           GdkRectangle rect;
 765
 766           recompute_drawable ((GdkDrawable *)window);
 767
 768           send_map_events (private, TRUE);
 769
 770           mousewin = gdk_window_at_pointer (NULL, NULL);
 771           gdk_fb_window_send_crossing_events (NULL,
 772                                               mousewin,
 773                                               GDK_CROSSING_NORMAL);
 774
 775           if (private->input_only)
 776             return;
 777
 778           rect.x = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_x;
 779           rect.y = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_y;
 780           rect.width = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_x - rect.x;
 781           rect.height = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_y - rect.y;
 782           gdk_window_invalidate_rect (_gdk_parent_root, &rect, TRUE);
 783         }
 784     }
 785 }
 786
 787 void
 788 gdk_window_show_unraised (GdkWindow *window)
 789 {
 790   g_return_if_fail (window != NULL);
 791
 792   show_window_internal (window, FALSE);
 793 }
 794
 795 void
 796 gdk_window_show (GdkWindow *window)
 797 {
 798   g_return_if_fail (window != NULL);
 799
 800   show_window_internal (window, TRUE);
 801 }
 802
 803 void
 804 gdk_window_hide (GdkWindow *window)
 805 {
 806   GdkWindowObject *private;
 807   GdkWindow *mousewin;
 808   GdkWindow *event_win;
 809
 810   g_return_if_fail (window != NULL);
 811
 812   private = (GdkWindowObject*) window;
 813
 814   if (!private->destroyed && GDK_WINDOW_IS_MAPPED (private))
 815     {
 816       GdkEvent *event;
 817       GdkRectangle r;
 818       gboolean do_hide;
 819
 820       event_win = gdk_fb_other_event_window (window, GDK_UNMAP);
 821       if (event_win)
 822         event = gdk_event_make (event_win, GDK_UNMAP, TRUE);
 823
 824       r.x = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_x;
 825       r.y = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_y;
 826       r.width = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_x - r.x;
 827       r.height = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_y - r.y;
 828
 829       private->state = GDK_WINDOW_STATE_WITHDRAWN;
 830
 831       mousewin = gdk_window_at_pointer (NULL, NULL);
 832       gdk_fb_window_send_crossing_events (NULL,
 833                                           mousewin,
 834                                           GDK_CROSSING_NORMAL);
 835
 836       do_hide = gdk_fb_cursor_need_hide (&r);
 837
 838       if (do_hide)
 839         gdk_fb_cursor_hide ();
 840       if (window == _gdk_fb_pointer_grab_window)
 841         gdk_pointer_ungrab (GDK_CURRENT_TIME);
 842       if (window == _gdk_fb_keyboard_grab_window)
 843         gdk_keyboard_ungrab (GDK_CURRENT_TIME);
 844
 845       /* Clear the root window, as it might be visible under
 846          the hidden window*/
 847       gdk_window_clear_area (_gdk_parent_root,
 848                              r.x,
 849                              r.y,
 850                              r.width,
 851                              r.height);
 852       /* Invalidate the rect */
 853       gdk_window_invalidate_rect (_gdk_parent_root, &r, TRUE);
 854
 855       if (do_hide)
 856         gdk_fb_cursor_unhide ();
 857     }
 858 }
 859
 860 void
 861 gdk_window_withdraw (GdkWindow *window)
 862 {
 863   gdk_window_hide (window);
 864 }
 865
 866 void
 867 gdk_window_move (GdkWindow *window,
 868                  gint       x,
 869                  gint       y)
 870 {
 871   GdkWindowObject *private = (GdkWindowObject *)window;
 872
 873   g_return_if_fail (window != NULL);
 874   g_return_if_fail (GDK_IS_WINDOW (window));
 875
 876   gdk_window_move_resize (window, x, y,
 877                           GDK_DRAWABLE_IMPL_FBDATA (private)->width,
 878                           GDK_DRAWABLE_IMPL_FBDATA (private)->height);
 879 }
 880
 881 void
 882 gdk_window_resize (GdkWindow *window,
 883                    gint       width,
 884                    gint       height)
 885 {
 886   GdkWindowObject *private;
 887   gint x, y;
 888
 889   g_return_if_fail (window != NULL);
 890   g_return_if_fail (GDK_IS_WINDOW (window));
 891
 892   private = (GdkWindowObject*) window;
 893
 894   if (width < 1)
 895     width = 1;
 896   if (height < 1)
 897     height = 1;
 898
 899   x = private->x;
 900   y = private->y;
 901
 902   if (private->parent && (private->parent->window_type != GDK_WINDOW_CHILD))
 903     {
 904       GdkWindowChildHandlerData *data;
 905
 906       data = g_object_get_data (G_OBJECT (private->parent), "gdk-window-child-handler");
 907
 908       if (data)
 909         (*data->get_pos) (window, &x, &y, data->user_data);
 910     }
 911
 912   gdk_window_move_resize (window, x, y, width, height);
 913 }
 914
 915 static void
 916 recompute_abs_positions(GdkDrawable *drawable,
 917                         gint parent_x, gint parent_y,
 918                         gint parent_llim_x, gint parent_llim_y,
 919                         gint parent_lim_x, gint parent_lim_y)
 920 {
 921   GList *l;
 922
 923   if (GDK_IS_WINDOW (drawable))
 924     {
 925       GdkWindowObject *private = GDK_WINDOW_P (drawable);
 926       int x, y;
 927
 928       if (!GDK_WINDOW_IS_MAPPED (private))
 929         return;
 930
 931
 932       GDK_DRAWABLE_IMPL_FBDATA (private)->abs_x = parent_x + private->x;
 933       GDK_DRAWABLE_IMPL_FBDATA (private)->abs_y = parent_y + private->y;
 934       x = MAX (parent_llim_x, GDK_DRAWABLE_IMPL_FBDATA (private)->abs_x);
 935       x = MIN (x, parent_lim_x);
 936       GDK_DRAWABLE_IMPL_FBDATA (private)->llim_x = x;
 937       y = MAX (parent_llim_y, GDK_DRAWABLE_IMPL_FBDATA (private)->abs_y);
 938       y = MIN (y, parent_lim_y);
 939       GDK_DRAWABLE_IMPL_FBDATA (private)->llim_y = y;
 940       x = MIN (parent_lim_x,
 941                GDK_DRAWABLE_IMPL_FBDATA (private)->abs_x + GDK_DRAWABLE_IMPL_FBDATA (private)->width);
 942       x = MAX (x, GDK_DRAWABLE_IMPL_FBDATA (private)->llim_x);
 943       GDK_DRAWABLE_IMPL_FBDATA (private)->lim_x = x;
 944       y = MIN (parent_lim_y,
 945                GDK_DRAWABLE_IMPL_FBDATA (private)->abs_y + GDK_DRAWABLE_IMPL_FBDATA (private)->height);
 946       y = MAX (y, GDK_DRAWABLE_IMPL_FBDATA (private)->llim_y);
 947       GDK_DRAWABLE_IMPL_FBDATA (private)->lim_y = y;
 948
 949       g_assert (GDK_DRAWABLE_IMPL_FBDATA (private)->llim_x <= GDK_DRAWABLE_IMPL_FBDATA (private)->lim_x);
 950       g_assert (GDK_DRAWABLE_IMPL_FBDATA (private)->llim_y <= GDK_DRAWABLE_IMPL_FBDATA (private)->lim_y);
 951
 952       for (l = private->children; l; l = l->next)
 953         recompute_abs_positions (l->data,
 954                                  GDK_DRAWABLE_IMPL_FBDATA (private)->abs_x,
 955                                  GDK_DRAWABLE_IMPL_FBDATA (private)->abs_y,
 956                                  GDK_DRAWABLE_IMPL_FBDATA (private)->llim_x,
 957                                  GDK_DRAWABLE_IMPL_FBDATA (private)->llim_y,
 958                                  GDK_DRAWABLE_IMPL_FBDATA (private)->lim_x,
 959                                  GDK_DRAWABLE_IMPL_FBDATA (private)->lim_y);
 960     }
 961   else
 962     {
 963       GDK_DRAWABLE_IMPL_FBDATA (drawable)->abs_x = 0;
 964       GDK_DRAWABLE_IMPL_FBDATA (drawable)->abs_y = 0;
 965       GDK_DRAWABLE_IMPL_FBDATA (drawable)->llim_x = 0;
 966       GDK_DRAWABLE_IMPL_FBDATA (drawable)->llim_y = 0;
 967       GDK_DRAWABLE_IMPL_FBDATA (drawable)->lim_x = GDK_DRAWABLE_IMPL_FBDATA (drawable)->width;
 968       GDK_DRAWABLE_IMPL_FBDATA (drawable)->lim_y = GDK_DRAWABLE_IMPL_FBDATA (drawable)->height;
 969     }
 970 }
 971
 972 static void
 973 recompute_rowstride(GdkDrawable *drawable)
 974 {
 975   GList *l;
 976   GdkWindowObject *private;
 977
 978   g_return_if_fail (GDK_IS_WINDOW (drawable));
 979
 980   private = GDK_WINDOW_P (drawable);
 981
 982   GDK_DRAWABLE_IMPL_FBDATA (private)->rowstride = gdk_display->fb_stride;
 983   for (l = private->children; l; l = l->next)
 984     recompute_rowstride (l->data);
 985 }
 986
 987 void
 988 gdk_fb_recompute_all (void)
 989 {
 990   GDK_DRAWABLE_IMPL_FBDATA (_gdk_parent_root)->width = gdk_display->fb_width;
 991   GDK_DRAWABLE_IMPL_FBDATA (_gdk_parent_root)->height = gdk_display->fb_height;
 992
 993   recompute_abs_positions (_gdk_parent_root,
 994                            0, 0, 0, 0,
 995                            gdk_display->fb_width, gdk_display->fb_height);
 996   recompute_rowstride (_gdk_parent_root);
 997 }
 998
 999 static void
1000 recompute_drawable (GdkDrawable *drawable)
1001 {
1002   if (GDK_IS_WINDOW (drawable))
1003     {
1004       GdkWindowObject *private = GDK_WINDOW_P (drawable);
1005       GdkWindow *parent;
1006
1007       parent = (GdkWindow *)private->parent;
1008       if (!parent)
1009         parent = _gdk_parent_root;
1010
1011       recompute_abs_positions (drawable,
1012                                GDK_DRAWABLE_IMPL_FBDATA (parent)->abs_x,
1013                                GDK_DRAWABLE_IMPL_FBDATA (parent)->abs_y,
1014                                GDK_DRAWABLE_IMPL_FBDATA (parent)->llim_x,
1015                                GDK_DRAWABLE_IMPL_FBDATA (parent)->llim_y,
1016                                GDK_DRAWABLE_IMPL_FBDATA (parent)->lim_x,
1017                                GDK_DRAWABLE_IMPL_FBDATA (parent)->lim_y);
1018     }
1019   else
1020     recompute_abs_positions (drawable, 0, 0, 0, 0, INT_MAX, INT_MAX);
1021 }
1022
1023 void
1024 gdk_fb_window_move_resize (GdkWindow *window,
1025                            gint       x,
1026                            gint       y,
1027                            gint       width,
1028                            gint       height,
1029                            gboolean   send_expose_events)
1030 {
1031   GdkWindowObject *private;
1032   gint dx, dy, dw, dh;
1033   gint i, draw_dir;
1034   GdkEvent *event;
1035   GdkWindow *mousewin;
1036   GdkRectangle root_rect;
1037   GdkRectangle update_rect;
1038
1039   g_return_if_fail (window != NULL);
1040   g_return_if_fail (GDK_IS_WINDOW (window));
1041
1042   if (width < 1)
1043     width = 1;
1044   if (height < 1)
1045     height = 1;
1046
1047   private = (GdkWindowObject*) window;
1048
1049   if (private->parent && (private->parent->window_type != GDK_WINDOW_CHILD))
1050     {
1051       GdkWindowChildHandlerData *data;
1052
1053       data = g_object_get_data (G_OBJECT (private->parent), "gdk-window-child-handler");
1054
1055       if (data && (*data->changed) (window, x, y, width, height, data->user_data))
1056           return;
1057     }
1058
1059   if (!private->destroyed)
1060     {
1061       GdkRegion *old_region = NULL;
1062
1063       if (private->input_only)
1064         send_expose_events = FALSE;
1065
1066       if (GDK_WINDOW_IS_MAPPED (private) && send_expose_events)
1067         old_region = gdk_fb_clip_region (GDK_DRAWABLE_IMPL(window), NULL, TRUE, FALSE, FALSE);
1068
1069       dx = x - private->x;
1070       dy = y - private->y;
1071       dw = width - GDK_DRAWABLE_IMPL_FBDATA (private)->width;
1072       dh = height - GDK_DRAWABLE_IMPL_FBDATA (private)->height;
1073
1074       private->x = x;
1075       private->y = y;
1076       GDK_DRAWABLE_IMPL_FBDATA (private)->width = width;
1077       GDK_DRAWABLE_IMPL_FBDATA (private)->height = height;
1078
1079       if (GDK_WINDOW_IS_MAPPED (private))
1080         {
1081           recompute_drawable ((GdkDrawable *)window);
1082
1083           if (send_expose_events)
1084             {
1085               GdkRegion *new_region, *region;
1086               gboolean handle_cursor = FALSE;
1087
1088               new_region = gdk_fb_clip_region (GDK_DRAWABLE_IMPL (window), NULL, TRUE, FALSE, TRUE);
1089
1090               region = gdk_region_copy (old_region);
1091               gdk_region_offset (region, dx, dy);
1092               gdk_region_intersect (region, new_region);
1093
1094               if (region->numRects && ((dx != 0) || (dy != 0)))
1095                 {
1096                   GdkFBDrawingContext fbdc;
1097
1098                   if (gdk_fb_cursor_region_need_hide (old_region) ||
1099                       gdk_fb_cursor_region_need_hide (new_region))
1100                     {
1101                       gdk_fb_cursor_hide ();
1102                       handle_cursor = TRUE;
1103                     }
1104
1105                   gdk_fb_drawing_context_init (&fbdc, GDK_DRAWABLE_IMPL (_gdk_parent_root), NULL, FALSE, FALSE);
1106
1107                   draw_dir = 1;
1108                   if ((dy>0) || ((dy==0) && (dx>0)))
1109                     draw_dir = -1;
1110
1111                   for (i=(draw_dir>0)?0:region->numRects-1;i >= 0 && i < region->numRects; i+=draw_dir)
1112                     {
1113                       GdkRegionBox *reg = &region->rects[i];
1114
1115                       gdk_fb_draw_drawable_3 (GDK_DRAWABLE_IMPL(_gdk_parent_root),
1116                                               _gdk_fb_screen_gc,
1117                                               GDK_DRAWABLE_IMPL(_gdk_parent_root),
1118                                               &fbdc,
1119                                               (reg->x1 - dx),
1120                                               (reg->y1 - dy),
1121                                               (reg->x1),
1122                                               (reg->y1),
1123                                               (reg->x2 - reg->x1),
1124                                               (reg->y2 - reg->y1));
1125                     }
1126                   gdk_fb_drawing_context_finalize (&fbdc);
1127                 }
1128               gdk_shadow_fb_update (region->extents.x1, region->extents.y1,
1129                                     region->extents.x2, region->extents.y2);
1130
1131               gdk_region_union (new_region, old_region);
1132               gdk_region_subtract (new_region, region);
1133               gdk_region_destroy (region);
1134
1135
1136               /* Clear the root window in new_region */
1137               root_rect.x = 0;
1138               root_rect.y = 0;
1139               root_rect.width = gdk_screen_width();
1140               root_rect.height = gdk_screen_height();
1141               gdk_region_get_clipbox (new_region, &update_rect);
1142               if (gdk_rectangle_intersect (&update_rect, &root_rect, &update_rect))
1143                 gdk_window_clear_area (_gdk_parent_root,
1144                                        update_rect.x,
1145                                        update_rect.y,
1146                                        update_rect.width,
1147                                        update_rect.height);
1148               /* Invalidate regions in new_region */
1149               gdk_window_invalidate_region (_gdk_parent_root, new_region, TRUE);
1150
1151               if (handle_cursor)
1152                 gdk_fb_cursor_unhide ();
1153
1154               gdk_region_destroy (old_region);
1155               gdk_region_destroy (new_region);
1156             }
1157           /* Send GdkEventConfigure for toplevel windows */
1158           if (private->window_type != GDK_WINDOW_CHILD)
1159             {
1160               GdkWindow *event_win;
1161               event_win = gdk_fb_other_event_window (window, GDK_CONFIGURE);
1162               if (event_win)
1163                 {
1164                   event = gdk_event_make (event_win, GDK_CONFIGURE, TRUE);
1165                   event->configure.x = private->x;
1166                   event->configure.y = private->y;
1167                   event->configure.width = GDK_DRAWABLE_IMPL_FBDATA (private)->width;
1168                   event->configure.height = GDK_DRAWABLE_IMPL_FBDATA (private)->height;
1169                 }
1170             }
1171
1172           /* The window the pointer is in might have changed */
1173           mousewin = gdk_window_at_pointer (NULL, NULL);
1174           gdk_fb_window_send_crossing_events (NULL,
1175                                               mousewin,
1176                                               GDK_CROSSING_NORMAL);
1177         }
1178     }
1179 }
1180
1181 void
1182 gdk_window_move_resize (GdkWindow *window,
1183                         gint       x,
1184                         gint       y,
1185                         gint       width,
1186                         gint       height)
1187 {
1188   gdk_fb_window_move_resize (window, x, y, width, height, TRUE);
1189 }
1190
1191 void
1192 gdk_window_reparent (GdkWindow *window,
1193                      GdkWindow *new_parent,
1194                      gint       x,
1195                      gint       y)
1196 {
1197   GdkWindowObject *window_private;
1198   GdkWindowObject *parent_private;
1199   GdkWindowObject *old_parent_private;
1200
1201   g_return_if_fail (window != NULL);
1202   g_return_if_fail (GDK_IS_WINDOW (window));
1203   g_return_if_fail (new_parent != NULL);
1204   g_return_if_fail (GDK_IS_WINDOW (new_parent));
1205
1206   if (!new_parent)
1207     new_parent = _gdk_parent_root;
1208
1209   window_private = (GdkWindowObject*) window;
1210   old_parent_private = (GdkWindowObject*)window_private->parent;
1211   parent_private = (GdkWindowObject*) new_parent;
1212
1213   g_assert(GDK_DRAWABLE_IMPL_FBDATA (window_private)->colormap);
1214
1215   window_private->parent = (GdkWindowObject *)new_parent;
1216
1217   if (old_parent_private)
1218     old_parent_private->children = g_list_remove (old_parent_private->children, window);
1219
1220   parent_private->children = g_list_prepend (parent_private->children, window);
1221
1222   if (GDK_WINDOW_IS_MAPPED (window_private))
1223     {
1224       GdkRectangle r;
1225       GdkRegion *region;
1226
1227       r.x = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_x;
1228       r.y = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_y;
1229       r.width = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_x - r.x;
1230       r.height = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_y - r.y;
1231       region = gdk_region_rectangle (&r);
1232
1233       recompute_drawable ((GdkDrawable *)window);
1234       r.x = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_x;
1235       r.y = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_y;
1236       r.width = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_x - r.x;
1237       r.height = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_y - r.y;
1238       gdk_region_union_with_rect (region, &r);
1239
1240       gdk_window_invalidate_region (_gdk_parent_root, region, TRUE);
1241       gdk_region_destroy (region);
1242     }
1243 }
1244
1245
1246 void
1247 _gdk_windowing_window_clear_area (GdkWindow *window,
1248                                   gint       x,
1249                                   gint       y,
1250                                   gint       width,
1251                                   gint       height)
1252 {
1253   GdkPixmap *bgpm;
1254   GdkWindow *relto;
1255
1256   if (GDK_WINDOW_P (window)->input_only)
1257     return;
1258
1259   bgpm = GDK_WINDOW_P (window)->bg_pixmap;
1260
1261   if (width == 0)
1262     width = GDK_DRAWABLE_IMPL_FBDATA (window)->width - x;
1263
1264   if (height == 0)
1265     height = GDK_DRAWABLE_IMPL_FBDATA (window)->height - y;
1266
1267   relto = window;
1268   while ((bgpm == GDK_PARENT_RELATIVE_BG) && relto)
1269     {
1270       relto = (GdkWindow *)GDK_WINDOW_P(relto)->parent;
1271       bgpm = GDK_WINDOW_P (relto)->bg_pixmap;
1272     }
1273
1274   if (bgpm && bgpm != GDK_NO_BG)
1275     {
1276       int curx, cury;
1277       int xstep, ystep;
1278       int xtrans, ytrans;
1279       GdkFBDrawingContext fbdc;
1280
1281       gdk_fb_drawing_context_init (&fbdc, GDK_DRAWABLE_IMPL (window), NULL, FALSE, TRUE);
1282
1283       xtrans = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_x - GDK_DRAWABLE_IMPL_FBDATA (relto)->abs_x;
1284       ytrans = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_y - GDK_DRAWABLE_IMPL_FBDATA (relto)->abs_y;
1285
1286       for (cury = y; cury < (y + height); cury += ystep)
1287         {
1288           int drawh = (cury + ytrans) % GDK_DRAWABLE_IMPL_FBDATA (bgpm)->height;
1289           ystep = GDK_DRAWABLE_IMPL_FBDATA (bgpm)->height - drawh;
1290
1291           ystep = MIN (ystep, y + height - cury);
1292
1293           for (curx = x; curx < (x + width); curx += xstep)
1294             {
1295               int draww = (curx + xtrans) % GDK_DRAWABLE_IMPL_FBDATA (bgpm)->width;
1296               xstep = GDK_DRAWABLE_IMPL_FBDATA (bgpm)->width - draww;
1297
1298               xstep = MIN (xstep, x + width - curx);
1299               gdk_fb_draw_drawable_3 (GDK_DRAWABLE_IMPL (window),
1300                                       _gdk_fb_screen_gc,
1301                                       GDK_DRAWABLE_IMPL (bgpm),
1302                                       &fbdc,
1303                                       draww, drawh,
1304                                       curx, cury,
1305                                       xstep, ystep);
1306             }
1307         }
1308
1309       gdk_fb_drawing_context_finalize (&fbdc);
1310     }
1311   else if (!bgpm)
1312     {
1313       if (relto == window)
1314         gdk_draw_rectangle (window, _gdk_fb_screen_gc, TRUE, x, y, width, height);
1315       else
1316         {
1317           /* GDK_PARENT_RELATIVE_BG, but no pixmap, get the color from the parent window. */
1318           GdkGC *gc;
1319           GdkGCValues values;
1320           values.foreground = GDK_WINDOW_P (relto)->bg_color;
1321           gc = gdk_gc_new_with_values (window, &values, GDK_GC_FOREGROUND);
1322           gdk_draw_rectangle (window, gc, TRUE, x, y, width, height);
1323           gdk_gc_unref (gc);
1324         }
1325     }
1326 }
1327
1328 /* What's the diff? */
1329 void
1330 _gdk_windowing_window_clear_area_e (GdkWindow *window,
1331                                     gint       x,
1332                                     gint       y,
1333                                     gint       width,
1334                                     gint       height)
1335 {
1336   _gdk_windowing_window_clear_area (window, x, y, width, height);
1337 }
1338
1339 static void
1340 gdk_fb_window_raise (GdkWindow *window)
1341 {
1342   GdkWindowObject *parent;
1343
1344   parent = GDK_WINDOW_OBJECT (window)->parent;
1345
1346   parent->children = g_list_remove (parent->children, window);
1347   parent->children = g_list_prepend (parent->children, window);
1348 }
1349
1350 static void
1351 gdk_fb_window_lower (GdkWindow *window)
1352 {
1353   GdkWindowObject *parent;
1354
1355   parent = GDK_WINDOW_OBJECT (window)->parent;
1356
1357   parent->children = g_list_remove (parent->children, window);
1358   parent->children = g_list_append (parent->children, window);
1359 }
1360
1361
1362 void
1363 gdk_window_raise (GdkWindow *window)
1364 {
1365   g_return_if_fail (window != NULL);
1366   g_return_if_fail (GDK_IS_WINDOW (window));
1367
1368   gdk_fb_window_raise (window);
1369
1370   if (GDK_WINDOW_OBJECT (window)->parent)
1371     gdk_window_invalidate_rect (window, NULL, TRUE);
1372 }
1373
1374 void
1375 gdk_window_lower (GdkWindow *window)
1376 {
1377   g_return_if_fail (window != NULL);
1378   g_return_if_fail (GDK_IS_WINDOW (window));
1379
1380   gdk_fb_window_lower (window);
1381
1382   if (GDK_WINDOW_OBJECT (window)->parent)
1383     gdk_window_invalidate_rect (window, NULL, TRUE);
1384 }
1385
1386 void
1387 gdk_window_set_hints (GdkWindow *window,
1388                       gint       x,
1389                       gint       y,
1390                       gint       min_width,
1391                       gint       min_height,
1392                       gint       max_width,
1393                       gint       max_height,
1394                       gint       flags)
1395 {
1396 }
1397
1398 void
1399 gdk_window_set_geometry_hints (GdkWindow      *window,
1400                                GdkGeometry    *geometry,
1401                                GdkWindowHints  geom_mask)
1402 {
1403 }
1404
1405 void
1406 gdk_window_set_title (GdkWindow   *window,
1407                       const gchar *title)
1408 {
1409 }
1410
1411 void
1412 gdk_window_set_role (GdkWindow   *window,
1413                      const gchar *role)
1414 {
1415 }
1416
1417 void
1418 gdk_window_set_transient_for (GdkWindow *window,
1419                               GdkWindow *parent)
1420 {
1421   GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
1422   GdkWindowObject *root = GDK_WINDOW_OBJECT (_gdk_parent_root);
1423   int i;
1424
1425   g_return_if_fail (window != NULL);
1426   g_return_if_fail (GDK_IS_WINDOW (window));
1427
1428   g_return_if_fail (parent != NULL);
1429   g_return_if_fail (GDK_IS_WINDOW (parent));
1430
1431   g_return_if_fail ((GdkWindow *)private->parent == _gdk_parent_root);
1432   g_return_if_fail ((GdkWindow *)GDK_WINDOW_OBJECT (parent)->parent == _gdk_parent_root);
1433
1434   root->children = g_list_remove (root->children, window);
1435
1436   i = g_list_index (root->children, parent);
1437   if (i<0)
1438     root->children = g_list_prepend (root->children, window);
1439   else
1440     root->children = g_list_insert (root->children, window, i);
1441 }
1442
1443 void
1444 gdk_window_set_background (GdkWindow      *window,
1445                            const GdkColor *color)
1446 {
1447   GdkWindowObject *private = (GdkWindowObject *)window;
1448
1449   g_return_if_fail (window != NULL);
1450   g_return_if_fail (GDK_IS_WINDOW (window));
1451
1452   private->bg_color = *color;
1453
1454   if (private->bg_pixmap &&
1455       private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1456       private->bg_pixmap != GDK_NO_BG)
1457     {
1458       gdk_pixmap_unref (private->bg_pixmap);
1459       private->bg_pixmap = NULL;
1460     }
1461 }
1462
1463 void
1464 gdk_window_set_back_pixmap (GdkWindow *window,
1465                             GdkPixmap *pixmap,
1466                             gboolean   parent_relative)
1467 {
1468   GdkWindowObject *private = (GdkWindowObject *)window;
1469   GdkPixmap *old_pixmap;
1470
1471   g_return_if_fail (window != NULL);
1472   g_return_if_fail (GDK_IS_WINDOW (window));
1473   g_return_if_fail (pixmap == NULL || !parent_relative);
1474   g_return_if_fail (pixmap == NULL || gdk_drawable_get_depth (window) == gdk_drawable_get_depth (pixmap));
1475
1476   if (pixmap && !gdk_drawable_get_colormap (pixmap))
1477     {
1478       g_warning ("gdk_window_set_back_pixmap(): pixmap must have a colormap");
1479       return;
1480     }
1481
1482   old_pixmap = private->bg_pixmap;
1483
1484   if (parent_relative)
1485     {
1486       private->bg_pixmap = GDK_PARENT_RELATIVE_BG;
1487     }
1488   else
1489     {
1490       if (pixmap)
1491         {
1492           gdk_pixmap_ref (pixmap);
1493           private->bg_pixmap = pixmap;
1494         }
1495       else
1496         {
1497           private->bg_pixmap = GDK_NO_BG;
1498         }
1499     }
1500
1501   if (old_pixmap &&
1502       old_pixmap != GDK_PARENT_RELATIVE_BG &&
1503       old_pixmap != GDK_NO_BG)
1504     gdk_pixmap_unref (old_pixmap);
1505 }
1506
1507 void
1508 gdk_window_set_cursor (GdkWindow *window,
1509                        GdkCursor *cursor)
1510 {
1511   GdkCursor *old_cursor = GDK_WINDOW_IMPL_FBDATA(window)->cursor;
1512   GdkRectangle window_reg;
1513
1514   GDK_WINDOW_IMPL_FBDATA (window)->cursor = cursor ? gdk_cursor_ref (cursor) : NULL;
1515
1516   if (old_cursor)
1517     gdk_cursor_unref (old_cursor);
1518
1519   window_reg.x = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_x;
1520   window_reg.y = GDK_DRAWABLE_IMPL_FBDATA (window)->llim_y;
1521   window_reg.width = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_x - window_reg.x;
1522   window_reg.height = GDK_DRAWABLE_IMPL_FBDATA (window)->lim_y - window_reg.y;
1523   if (gdk_fb_cursor_need_hide (&window_reg))
1524     gdk_fb_cursor_reset ();
1525 }
1526
1527 void
1528 gdk_window_get_geometry (GdkWindow *window,
1529                          gint      *x,
1530                          gint      *y,
1531                          gint      *width,
1532                          gint      *height,
1533                          gint      *depth)
1534 {
1535   GdkWindowObject *private = (GdkWindowObject *)window;
1536
1537   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1538
1539   if (!window)
1540     window = _gdk_parent_root;
1541
1542   if (!private->destroyed)
1543     {
1544
1545       if (x)
1546         *x = private->x;
1547       if (y)
1548         *y = private->y;
1549       if (width)
1550         *width = GDK_DRAWABLE_IMPL_FBDATA (window)->width;
1551       if (height)
1552         *height = GDK_DRAWABLE_IMPL_FBDATA (window)->height;
1553       if (depth)
1554         *depth = gdk_display->modeinfo.bits_per_pixel;
1555     }
1556 }
1557
1558 gboolean
1559 gdk_window_get_origin (GdkWindow *window,
1560                        gint      *x,
1561                        gint      *y)
1562 {
1563   g_return_val_if_fail (window != NULL, FALSE);
1564
1565   if (x)
1566     *x = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_x;
1567   if (y)
1568     *y = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_y;
1569
1570   return TRUE;
1571 }
1572
1573 gboolean
1574 gdk_window_get_deskrelative_origin (GdkWindow *window,
1575                                     gint      *x,
1576                                     gint      *y)
1577 {
1578   gint tx = 0;
1579   gint ty = 0;
1580   gboolean return_val;
1581
1582   g_return_val_if_fail (window != NULL, 0);
1583
1584   if (!GDK_WINDOW_DESTROYED (window))
1585     {
1586       tx = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_x;
1587       ty = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_y;
1588
1589       return_val = TRUE;
1590     }
1591   else
1592     return_val = FALSE;
1593
1594   if (x)
1595     *x = tx;
1596   if (y)
1597     *y = ty;
1598
1599   return return_val;
1600 }
1601
1602 void
1603 gdk_window_get_root_origin (GdkWindow *window,
1604                             gint      *x,
1605                             gint      *y)
1606 {
1607   gdk_window_get_deskrelative_origin (window, x, y);
1608 }
1609
1610 static GdkRegion*
1611 gdk_window_fb_get_visible_region (GdkDrawable *drawable)
1612 {
1613   GdkDrawableFBData *priv = GDK_DRAWABLE_FBDATA (drawable);
1614   GdkRectangle result_rect;
1615   GdkRectangle screen_rect;
1616
1617   result_rect.x = 0;
1618   result_rect.y = 0;
1619   result_rect.width = priv->width;
1620   result_rect.height = priv->height;
1621
1622   screen_rect.x = -priv->abs_x;
1623   screen_rect.y = -priv->abs_y;
1624   screen_rect.width = gdk_display->fb_width;
1625   screen_rect.height = gdk_display->fb_height;
1626
1627   gdk_rectangle_intersect (&result_rect, &screen_rect, &result_rect);
1628
1629   return gdk_region_rectangle (&result_rect);
1630 }
1631
1632 GdkWindow *
1633 _gdk_windowing_window_get_pointer (GdkDisplay      *display,
1634                                    GdkWindow       *window,
1635                                    gint            *x,
1636                                    gint            *y,
1637                                    GdkModifierType *mask)
1638 {
1639   GdkWindow *return_val;
1640   int winx = 0;
1641   int winy = 0;
1642   int x_int, y_int;
1643   gint shape_dx, shape_dy;
1644   GdkRegion *shape;
1645
1646   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1647
1648   gdk_window_get_root_origin (window, &x_int, &y_int);
1649   gdk_fb_mouse_get_info (&winx, &winy, mask);
1650
1651   winx -= x_int;
1652   winy -= y_int;
1653
1654   *x = winx;
1655   *y = winy;
1656
1657   return_val = NULL;
1658
1659   shape = gdk_fb_window_peek_shape (window, &shape_dx, &shape_dy);
1660   if ((winx >= 0) && (winx < GDK_DRAWABLE_IMPL_FBDATA (window)->width) &&
1661       (winy >= 0) && (winy < GDK_DRAWABLE_IMPL_FBDATA (window)->height) &&
1662       (!shape || gdk_region_point_in (shape, winx - shape_dx, winy - shape_dy)))
1663     {
1664       GdkWindowObject *private;
1665       GdkWindowObject *sub;
1666       int subx = winx, suby = winy;
1667
1668       for (private = sub = (GdkWindowObject *)window; sub; private = sub)
1669         {
1670           GList *ltmp;
1671
1672           for (ltmp = private->children; ltmp; ltmp = ltmp->next)
1673             {
1674               sub = ltmp->data;
1675
1676               if (!GDK_WINDOW_IS_MAPPED (sub))
1677                 continue;
1678
1679               shape = gdk_fb_window_peek_shape (GDK_WINDOW (sub),
1680                                                 &shape_dx, &shape_dy);
1681               if (subx >= sub->x &&
1682                   (subx < (GDK_DRAWABLE_IMPL_FBDATA (sub)->width + sub->x)) &&
1683                   (suby >= sub->y) &&
1684                   (suby < (GDK_DRAWABLE_IMPL_FBDATA (sub)->height + sub->y)) &&
1685                   (!shape || gdk_region_point_in (shape, subx - sub->x - shape_dx, suby - sub->y - shape_dy)))
1686                 {
1687                   subx -= sub->x;
1688                   suby -= sub->y;
1689                   break;
1690                 }
1691             }
1692
1693           if (!ltmp)
1694             {
1695               sub = NULL;
1696               break;
1697             }
1698         }
1699
1700       return_val = (GdkWindow *)private;
1701     }
1702
1703   if (!return_val)
1704     return_val = _gdk_parent_root;
1705
1706   return return_val;
1707 }
1708
1709 void
1710 _gdk_windowing_get_pointer (GdkDisplay       *display,
1711                             GdkScreen       **screen,
1712                             gint             *x,
1713                             gint             *y,
1714                             GdkModifierType  *mask)
1715 {
1716   GdkScreen *default_screen = gdk_display_get_default_screen (display);
1717   GdkWindow *root_window = gdk_screen_get_root_window (default_screen);
1718
1719   *screen = default_screen;
1720   _gdk_windowing_window_get_pointer (display, root_window, x, y, mask);
1721 }
1722
1723 GdkWindow*
1724 _gdk_windowing_window_at_pointer (GdkDisplay *display,
1725                                   gint       *win_x,
1726                                   gint       *win_y)
1727 {
1728   gint rx, ry;
1729   GdkWindow *retval = gdk_window_get_pointer (NULL, win_x, win_y, NULL);
1730
1731   if (retval)
1732     {
1733       gdk_window_get_origin (retval, &ry, &rx);
1734       (*win_x) -= rx;
1735       (*win_y) -= ry;
1736     }
1737
1738   return retval;
1739 }
1740
1741 GdkEventMask
1742 gdk_window_get_events (GdkWindow *window)
1743 {
1744   g_return_val_if_fail (window != NULL, 0);
1745   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
1746
1747   if (GDK_WINDOW_DESTROYED (window))
1748     return 0;
1749   else
1750     return GDK_WINDOW_OBJECT (window)->event_mask;
1751 }
1752
1753 void
1754 gdk_window_set_events (GdkWindow       *window,
1755                        GdkEventMask     event_mask)
1756 {
1757
1758   g_return_if_fail (window != NULL);
1759   g_return_if_fail (GDK_IS_WINDOW (window));
1760
1761   if (event_mask & GDK_BUTTON_MOTION_MASK)
1762     event_mask |=
1763       GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
1764       GDK_BUTTON3_MOTION_MASK;
1765
1766   GDK_WINDOW_OBJECT (window)->event_mask = GDK_STRUCTURE_MASK | event_mask;
1767 }
1768
1769 void
1770 gdk_window_add_colormap_windows (GdkWindow *window)
1771 {
1772   g_return_if_fail (window != NULL);
1773   g_return_if_fail (GDK_IS_WINDOW (window));
1774
1775   /* N/A */
1776 }
1777
1778
1779 GdkRegion*
1780 gdk_fb_region_create_from_bitmap (GdkBitmap *bitmap)
1781 {
1782   GdkDrawableFBData *private;
1783   GdkRegion *region;
1784   GdkRectangle rect;
1785   gboolean in_rect;
1786   gint x;
1787   guchar bit_mask;
1788   guchar *src;
1789
1790   g_return_val_if_fail(bitmap != NULL, NULL);
1791   g_return_val_if_fail(GDK_IS_PIXMAP(bitmap), NULL);
1792
1793   private = GDK_DRAWABLE_IMPL_FBDATA (bitmap);
1794
1795   g_return_val_if_fail(private->depth == 1, NULL);
1796
1797   region = gdk_region_new();
1798
1799   rect.height = 1;
1800
1801   in_rect = FALSE; /* Haven't started a rectangle yet */
1802
1803   for (rect.y = 0; rect.y < private->height; (rect.y)++)
1804     {
1805       src = private->mem + rect.y * private->rowstride;
1806       bit_mask = 1;
1807       for (x = 0; x < private->width; x++)
1808         {
1809           if ((*src & bit_mask) && !in_rect)
1810             {
1811               /* Start of rect */
1812               in_rect = TRUE;
1813               rect.x = x;
1814             }
1815           else if (!(*src & bit_mask) && in_rect)
1816             {
1817               /* End of rect */
1818               in_rect = FALSE;
1819               rect.width = x - rect.x;
1820               gdk_region_union_with_rect (region, &rect);
1821             }
1822
1823           if (bit_mask == 1<<7)
1824             {
1825               bit_mask = 1;
1826               src++;
1827             }
1828           else
1829             bit_mask <<= 1;
1830         }
1831
1832       if (in_rect)
1833         {
1834           /* Past end of line */
1835           in_rect = FALSE;
1836           rect.width = x - rect.x;
1837           gdk_region_union_with_rect (region, &rect);
1838         }
1839     }
1840
1841   return region;
1842 }
1843
1844 GdkRegion *
1845 gdk_fb_window_peek_shape (GdkDrawable *window, gint *dx, gint *dy)
1846 {
1847   gint x, y;
1848
1849   if (!GDK_IS_WINDOW (window))
1850     return NULL;
1851
1852   if (GDK_WINDOW_IMPL_FBDATA (window)->shape == NULL)
1853     return NULL;
1854
1855   x = y = 0;
1856
1857   while (GDK_WINDOW_IMPL_FBDATA (window)->shape == GDK_FB_USE_CHILD_SHAPE)
1858     {
1859       GList *children;
1860       children = ((GdkWindowObject*)window)->children;
1861       if (children)
1862         {
1863           window = (GdkDrawable *)children->data;
1864           x += GDK_WINDOW_P(window)->x;
1865           y += GDK_WINDOW_P(window)->y;
1866         }
1867       else
1868         return NULL;
1869     }
1870
1871   *dx = x;
1872   *dy = y;
1873
1874   return GDK_WINDOW_IMPL_FBDATA (window)->shape;
1875 }
1876 GdkRegion *
1877 gdk_fb_window_get_abs_shape (GdkDrawable *window)
1878 {
1879   GdkRegion *shape;
1880
1881   if (!GDK_IS_WINDOW (window))
1882     return NULL;
1883
1884   if (GDK_WINDOW_IMPL_FBDATA (window)->shape == NULL)
1885     return NULL;
1886
1887   if (GDK_WINDOW_IMPL_FBDATA (window)->shape == GDK_FB_USE_CHILD_SHAPE)
1888     {
1889       GList *children;
1890       children = ((GdkWindowObject*)window)->children;
1891       if (children)
1892         return gdk_fb_window_get_abs_shape ((GdkDrawable *)children->data);
1893       else
1894         return NULL;
1895     }
1896
1897   shape = gdk_region_copy (GDK_WINDOW_IMPL_FBDATA (window)->shape);
1898   gdk_region_offset (shape,
1899                      GDK_DRAWABLE_IMPL_FBDATA (window)->abs_x,
1900                      GDK_DRAWABLE_IMPL_FBDATA (window)->abs_y);
1901   return shape;
1902 }
1903
1904
1905 static void
1906 _gdk_window_shape_combine_region (GdkWindow *window,
1907                                   GdkRegion *shape,
1908                                   gint       x,
1909                                   gint       y)
1910 {
1911   GdkWindowFBData *private;
1912   GdkDrawableFBData *drawable_private;
1913   GdkRegion *old_region = NULL;
1914   GdkRegion *new_region = NULL;
1915   GdkRectangle rect;
1916
1917   g_return_if_fail (window != NULL);
1918   g_return_if_fail (GDK_IS_WINDOW (window));
1919
1920   private = GDK_WINDOW_IMPL_FBDATA (window);
1921   drawable_private = GDK_DRAWABLE_IMPL_FBDATA (window);
1922
1923   if (GDK_WINDOW_IS_MAPPED (window))
1924     {
1925       old_region = gdk_fb_window_get_abs_shape (window);
1926       if (old_region == NULL)
1927         {
1928           rect.x = drawable_private->llim_x;
1929           rect.y = drawable_private->llim_y;
1930           rect.width = drawable_private->lim_x - rect.x;
1931           rect.height = drawable_private->lim_y - rect.y;
1932           old_region = gdk_region_rectangle (&rect);
1933         }
1934     }
1935
1936   if (private->shape && private->shape != GDK_FB_USE_CHILD_SHAPE)
1937     gdk_region_destroy (private->shape);
1938
1939   if (shape)
1940     {
1941       private->shape = shape;
1942       if (shape != GDK_FB_USE_CHILD_SHAPE)
1943         gdk_region_offset (private->shape, x, y);
1944     }
1945   else
1946     private->shape = NULL;
1947
1948   if (GDK_WINDOW_IS_MAPPED (window))
1949     {
1950       new_region = gdk_fb_window_get_abs_shape (window);
1951       if (new_region == NULL)
1952         {
1953           rect.x = drawable_private->llim_x;
1954           rect.y = drawable_private->llim_y;
1955           rect.width = drawable_private->lim_x - rect.x;
1956           rect.height = drawable_private->lim_y - rect.y;
1957           new_region = gdk_region_rectangle (&rect);
1958         }
1959
1960       gdk_region_subtract (old_region, new_region);
1961       gdk_region_destroy (new_region);
1962       gdk_window_invalidate_region (_gdk_parent_root, old_region, TRUE);
1963       gdk_region_destroy (old_region);
1964     }
1965 }
1966
1967 void
1968 gdk_window_shape_combine_mask (GdkWindow *window,
1969                                GdkBitmap *mask,
1970                                gint x, gint y)
1971 {
1972   _gdk_window_shape_combine_region (window,
1973                                     (mask == GDK_FB_USE_CHILD_SHAPE)?
1974                                     GDK_FB_USE_CHILD_SHAPE :
1975                                     mask ?
1976                                     gdk_fb_region_create_from_bitmap (mask) :
1977                                     NULL,
1978                                     x, y);
1979 }
1980
1981 void
1982 gdk_window_shape_combine_region (GdkWindow *window,
1983                                  GdkRegion *shape,
1984                                  gint       x,
1985                                  gint       y)
1986 {
1987   _gdk_window_shape_combine_region (window,
1988                                     gdk_region_copy (shape),
1989                                     x, y);
1990 }
1991
1992 void
1993 gdk_window_set_override_redirect (GdkWindow *window,
1994                                   gboolean override_redirect)
1995 {
1996   g_return_if_fail (window != NULL);
1997   g_return_if_fail (GDK_IS_WINDOW (window));
1998
1999   /* N/A */
2000 }
2001
2002 void
2003 gdk_window_set_accept_focus (GdkWindow *window,
2004                              gboolean accept_focus)
2005 {
2006   GdkWindowObject *private;
2007   g_return_if_fail (window != NULL);
2008   g_return_if_fail (GDK_IS_WINDOW (window));
2009
2010   private = (GdkWindowObject *)window;
2011
2012   accept_focus = accept_focus != FALSE;
2013
2014   if (private->accept_focus != accept_focus)
2015     private->accept_focus = accept_focus;
2016 }
2017
2018 void
2019 gdk_window_set_focus_on_map (GdkWindow *window,
2020                              gboolean focus_on_map)
2021 {
2022   GdkWindowObject *private;
2023   g_return_if_fail (window != NULL);
2024   g_return_if_fail (GDK_IS_WINDOW (window));
2025
2026   private = (GdkWindowObject *)window;
2027
2028   focus_on_map = focus_on_map != FALSE;
2029
2030   if (private->focus_on_map != focus_on_map)
2031     private->focus_on_map = focus_on_map;
2032 }
2033
2034 void
2035 gdk_window_set_icon (GdkWindow *window,
2036                      GdkWindow *icon_window,
2037                      GdkPixmap *pixmap,
2038                      GdkBitmap *mask)
2039 {
2040   g_return_if_fail (window != NULL);
2041   g_return_if_fail (GDK_IS_WINDOW (window));
2042
2043   /* N/A */
2044 }
2045
2046 void
2047 gdk_window_set_icon_name (GdkWindow *window,
2048                           const gchar *    name)
2049 {
2050   g_return_if_fail (window != NULL);
2051   g_return_if_fail (GDK_IS_WINDOW (window));
2052
2053   /* N/A */
2054 }
2055
2056 void
2057 gdk_window_set_group (GdkWindow *window,
2058                       GdkWindow *leader)
2059 {
2060   g_return_if_fail (window != NULL);
2061   g_return_if_fail (GDK_IS_WINDOW (window));
2062   g_return_if_fail (leader != NULL);
2063   g_return_if_fail (GDK_IS_WINDOW (leader));
2064
2065   /* N/A */
2066 }
2067
2068 void
2069 gdk_fb_window_set_child_handler (GdkWindow             *window,
2070                                  GdkWindowChildChanged  changed,
2071                                  GdkWindowChildGetPos   get_pos,
2072                                  gpointer               user_data)
2073 {
2074   GdkWindowChildHandlerData *data;
2075
2076   g_return_if_fail (window != NULL);
2077   g_return_if_fail (GDK_IS_WINDOW (window));
2078
2079   data = g_new (GdkWindowChildHandlerData, 1);
2080   data->changed = changed;
2081   data->get_pos = get_pos;
2082   data->user_data = user_data;
2083
2084   g_object_set_data_full (G_OBJECT (window), "gdk-window-child-handler",
2085                           data, (GDestroyNotify) g_free);
2086 }
2087
2088 void
2089 gdk_window_set_decorations (GdkWindow      *window,
2090                             GdkWMDecoration decorations)
2091 {
2092   GdkWMDecoration *dec;
2093
2094   g_return_if_fail (window != NULL);
2095   g_return_if_fail (GDK_IS_WINDOW (window));
2096
2097   dec = g_new (GdkWMDecoration, 1);
2098   *dec = decorations;
2099
2100   g_object_set_data_full (G_OBJECT (window), "gdk-window-decorations",
2101                           dec, (GDestroyNotify) g_free);
2102 }
2103
2104 gboolean
2105 gdk_window_get_decorations(GdkWindow *window,
2106                            GdkWMDecoration *decorations)
2107 {
2108   GdkWMDecoration *dec;
2109
2110   g_return_val_if_fail (window != NULL, FALSE);
2111   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2112
2113
2114   dec = g_object_get_data (G_OBJECT (window), "gdk-window-decorations");
2115   if (dec)
2116     {
2117       *decorations = *dec;
2118       return TRUE;
2119     }
2120   return FALSE;
2121 }
2122
2123 void
2124 gdk_window_set_functions (GdkWindow    *window,
2125                           GdkWMFunction functions)
2126 {
2127   g_return_if_fail (window != NULL);
2128   g_return_if_fail (GDK_IS_WINDOW (window));
2129
2130   /* N/A */
2131 }
2132
2133 void
2134 gdk_window_set_child_shapes (GdkWindow *window)
2135 {
2136   g_return_if_fail (window != NULL);
2137   g_return_if_fail (GDK_IS_WINDOW (window));
2138
2139 }
2140
2141 void
2142 gdk_window_merge_child_shapes (GdkWindow *window)
2143 {
2144   g_return_if_fail (window != NULL);
2145   g_return_if_fail (GDK_IS_WINDOW (window));
2146
2147 }
2148
2149 /*************************************************************
2150  * gdk_window_set_static_gravities:
2151  *     Set the bit gravity of the given window to static,
2152  *     and flag it so all children get static subwindow
2153  *     gravity.
2154  *   arguments:
2155  *     window: window for which to set static gravity
2156  *     use_static: Whether to turn static gravity on or off.
2157  *   results:
2158  *     Does the XServer support static gravity?
2159  *************************************************************/
2160
2161 gboolean
2162 gdk_window_set_static_gravities (GdkWindow *window,
2163                                  gboolean   use_static)
2164 {
2165   g_return_val_if_fail (window != NULL, FALSE);
2166   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2167
2168   return TRUE;
2169 }
2170
2171 void
2172 _gdk_windowing_window_get_offsets      (GdkWindow  *window,
2173                                         gint       *x_offset,
2174                                         gint       *y_offset)
2175 {
2176   *x_offset = *y_offset = 0;
2177 }
2178
2179 gboolean
2180 _gdk_windowing_window_queue_antiexpose (GdkWindow  *window,
2181                                         GdkRegion  *area)
2182 {
2183   return FALSE;
2184 }
2185
2186 void
2187 gdk_window_stick (GdkWindow *window)
2188 {
2189   g_return_if_fail (GDK_IS_WINDOW (window));
2190 }
2191
2192 void
2193 gdk_window_unstick (GdkWindow *window)
2194 {
2195   g_return_if_fail (GDK_IS_WINDOW (window));
2196 }
2197
2198 void
2199 gdk_window_maximize (GdkWindow *window)
2200 {
2201   g_return_if_fail (GDK_IS_WINDOW (window));
2202
2203   gdk_synthesize_window_state (window,
2204                                0,
2205                                GDK_WINDOW_STATE_MAXIMIZED);
2206 }
2207
2208 void
2209 gdk_window_unmaximize (GdkWindow *window)
2210 {
2211   g_return_if_fail (GDK_IS_WINDOW (window));
2212
2213   gdk_synthesize_window_state (window,
2214                                GDK_WINDOW_STATE_MAXIMIZED,
2215                                0);
2216 }
2217
2218 void
2219 gdk_window_iconify (GdkWindow *window)
2220 {
2221   g_return_if_fail (window != NULL);
2222   g_return_if_fail (GDK_IS_WINDOW (window));
2223
2224   g_warning ("gdk_window_iconify() not implemented.\n");
2225 }
2226
2227 void
2228 gdk_window_deiconify (GdkWindow *window)
2229 {
2230   g_return_if_fail (window != NULL);
2231   g_return_if_fail (GDK_IS_WINDOW (window));
2232
2233   /*  g_warning ("gdk_window_deiconify() not implemented.\n");*/
2234 }
2235
2236 void
2237 gdk_window_fullscreen (GdkWindow *window)
2238 {
2239   g_return_if_fail (GDK_IS_WINDOW (window));
2240
2241   g_warning ("gdk_window_fullscreen() not implemented.\n");
2242 }
2243
2244 void
2245 gdk_window_unfullscreen (GdkWindow *window)
2246 {
2247   g_return_if_fail (GDK_IS_WINDOW (window));
2248
2249   /*  g_warning ("gdk_window_unfullscreen() not implemented.\n");*/
2250 }
2251
2252 void
2253 gdk_window_set_keep_above (GdkWindow *window, gboolean setting)
2254 {
2255   g_return_if_fail (GDK_IS_WINDOW (window));
2256
2257   g_warning ("gdk_window_set_keep_above() not implemented.\n");
2258 }
2259
2260 void
2261 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
2262 {
2263   g_return_if_fail (GDK_IS_WINDOW (window));
2264
2265   g_warning ("gdk_window_set_keep_below() not implemented.\n");
2266 }
2267
2268 void
2269 gdk_window_focus (GdkWindow *window,
2270                   guint32    timestamp)
2271 {
2272   g_return_if_fail (GDK_IS_WINDOW (window));
2273
2274   g_warning ("gdk_window_focus() not implemented.\n");
2275 }
2276
2277 void
2278 gdk_window_set_type_hint (GdkWindow        *window,
2279                           GdkWindowTypeHint hint)
2280 {
2281   g_return_if_fail (window != NULL);
2282   g_return_if_fail (GDK_IS_WINDOW (window));
2283 }
2284
2285 void
2286 gdk_window_set_modal_hint (GdkWindow *window,
2287                            gboolean   modal)
2288 {
2289   g_return_if_fail (GDK_IS_WINDOW (window));
2290 }
2291
2292 void
2293 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
2294                                   gboolean   skips_taskbar)
2295 {
2296   g_return_if_fail (GDK_IS_WINDOW (window));
2297 }
2298
2299 void
2300 gdk_window_set_skip_pager_hint (GdkWindow *window,
2301                                 gboolean   skips_pager)
2302 {
2303   g_return_if_fail (GDK_IS_WINDOW (window));
2304 }
2305
2306 void
2307 gdk_window_begin_resize_drag (GdkWindow     *window,
2308                               GdkWindowEdge  edge,
2309                               gint           button,
2310                               gint           root_x,
2311                               gint           root_y,
2312                               guint32        timestamp)
2313 {
2314   g_return_if_fail (GDK_IS_WINDOW (window));
2315
2316 }
2317
2318 void
2319 gdk_window_begin_move_drag (GdkWindow *window,
2320                             gint       button,
2321                             gint       root_x,
2322                             gint       root_y,
2323                             guint32    timestamp)
2324 {
2325   g_return_if_fail (GDK_IS_WINDOW (window));
2326 }
2327
2328 void
2329 gdk_window_set_icon_list (GdkWindow *window,
2330                           GList     *pixbufs)
2331 {
2332   /* We don't support icons right now */
2333 }
2334
2335 /* No need to care about frames. Decoration is done by GtkWindow */
2336 void
2337 gdk_window_get_frame_extents (GdkWindow    *window,
2338                               GdkRectangle *rect)
2339 {
2340   g_return_if_fail (window != NULL);
2341
2342   rect->x = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_x;
2343   rect->y = GDK_DRAWABLE_IMPL_FBDATA (window)->abs_y;
2344   rect->width = GDK_DRAWABLE_IMPL_FBDATA (window)->width;
2345   rect->height = GDK_DRAWABLE_IMPL_FBDATA (window)->height;
2346 }
2347
2348 GdkWindow*
2349 gdk_window_foreign_new_for_display (GdkDisplay      *display,
2350                                     GdkNativeWindow  anid)
2351 {
2352   return (GdkWindow*) gdk_drawable_ref ((GdkDrawable *)anid);
2353 }
2354
2355 GdkWindow*
2356 gdk_window_lookup (GdkNativeWindow anid)
2357 {
2358   return (GdkWindow*) (anid);
2359 }
2360
2361 GdkWindow *
2362 gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
2363 {
2364   g_return_val_if_fail (display == gdk_display_get_default(), NULL);
2365
2366   return (GdkWindow*) (anid);
2367 }
2368
2369 void
2370 gdk_window_enable_synchronized_configure (GdkWindow *window)
2371 {
2372 }
2373
2374 void
2375 gdk_window_configure_finished (GdkWindow *window)
2376 {
2377 }