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

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * Copyright (C) 1998-2002 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.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include <stdlib.h>
  29
  30 #include "gdk.h" /* gdk_rectangle_intersect */
  31 #include "gdkevents.h"
  32 #include "gdkpixmap.h"
  33 #include "gdkwindow.h"
  34 #include "gdkdisplay.h"
  35 #include "gdkprivate-win32.h"
  36 #include "gdkinput-win32.h"
  37
  38 static GdkColormap* gdk_window_impl_win32_get_colormap (GdkDrawable *drawable);
  39 static void         gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
  40                                                         GdkColormap *cmap);
  41 static void         gdk_window_impl_win32_get_size     (GdkDrawable *drawable,
  42                                                         gint *width,
  43                                                         gint *height);
  44 static GdkRegion*   gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable);
  45 static void gdk_window_impl_win32_init       (GdkWindowImplWin32      *window);
  46 static void gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass);
  47 static void gdk_window_impl_win32_finalize   (GObject                 *object);
  48
  49 static gpointer parent_class = NULL;
  50
  51 GType
  52 _gdk_window_impl_win32_get_type (void)
  53 {
  54   static GType object_type = 0;
  55
  56   if (!object_type)
  57     {
  58       static const GTypeInfo object_info =
  59       {
  60         sizeof (GdkWindowImplWin32Class),
  61         (GBaseInitFunc) NULL,
  62         (GBaseFinalizeFunc) NULL,
  63         (GClassInitFunc) gdk_window_impl_win32_class_init,
  64         NULL,           /* class_finalize */
  65         NULL,           /* class_data */
  66         sizeof (GdkWindowImplWin32),
  67         0,              /* n_preallocs */
  68         (GInstanceInitFunc) gdk_window_impl_win32_init,
  69       };
  70
  71       object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_WIN32,
  72                                             "GdkWindowImplWin32",
  73                                             &object_info, 0);
  74     }
  75
  76   return object_type;
  77 }
  78
  79 GType
  80 _gdk_window_impl_get_type (void)
  81 {
  82   return _gdk_window_impl_win32_get_type ();
  83 }
  84
  85 static void
  86 gdk_window_impl_win32_init (GdkWindowImplWin32 *impl)
  87 {
  88   impl->width = 1;
  89   impl->height = 1;
  90
  91   impl->hcursor = NULL;
  92   impl->hint_flags = 0;
  93   impl->extension_events_selected = FALSE;
  94 }
  95
  96 static void
  97 gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass)
  98 {
  99   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 100   GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
 101
 102   parent_class = g_type_class_peek_parent (klass);
 103
 104   object_class->finalize = gdk_window_impl_win32_finalize;
 105
 106   drawable_class->set_colormap = gdk_window_impl_win32_set_colormap;
 107   drawable_class->get_colormap = gdk_window_impl_win32_get_colormap;
 108   drawable_class->get_size = gdk_window_impl_win32_get_size;
 109
 110   /* Visible and clip regions are the same */
 111   drawable_class->get_clip_region = gdk_window_impl_win32_get_visible_region;
 112   drawable_class->get_visible_region = gdk_window_impl_win32_get_visible_region;
 113 }
 114
 115 static void
 116 gdk_window_impl_win32_finalize (GObject *object)
 117 {
 118   GdkWindowObject *wrapper;
 119   GdkDrawableImplWin32 *draw_impl;
 120   GdkWindowImplWin32 *window_impl;
 121
 122   g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (object));
 123
 124   draw_impl = GDK_DRAWABLE_IMPL_WIN32 (object);
 125   window_impl = GDK_WINDOW_IMPL_WIN32 (object);
 126
 127   wrapper = (GdkWindowObject*) draw_impl->wrapper;
 128
 129   if (!GDK_WINDOW_DESTROYED (wrapper))
 130     {
 131       gdk_win32_handle_table_remove (draw_impl->handle);
 132     }
 133
 134   if (window_impl->hcursor != NULL)
 135     {
 136       if (GetCursor () == window_impl->hcursor)
 137         SetCursor (NULL);
 138       if (!DestroyCursor (window_impl->hcursor))
 139         WIN32_GDI_FAILED("DestroyCursor");
 140       window_impl->hcursor = NULL;
 141     }
 142
 143   G_OBJECT_CLASS (parent_class)->finalize (object);
 144 }
 145
 146 static GdkColormap*
 147 gdk_window_impl_win32_get_colormap (GdkDrawable *drawable)
 148 {
 149   GdkDrawableImplWin32 *drawable_impl;
 150
 151   g_return_val_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable), NULL);
 152
 153   drawable_impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
 154
 155   if (!((GdkWindowObject *) drawable_impl->wrapper)->input_only &&
 156       drawable_impl->colormap == NULL)
 157     {
 158       drawable_impl->colormap = gdk_colormap_get_system ();
 159       gdk_colormap_ref (drawable_impl->colormap);
 160     }
 161
 162   return drawable_impl->colormap;
 163 }
 164
 165 static void
 166 gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
 167                                     GdkColormap *cmap)
 168 {
 169   GdkWindowImplWin32 *impl;
 170   GdkDrawableImplWin32 *draw_impl;
 171
 172   g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable));
 173
 174   impl = GDK_WINDOW_IMPL_WIN32 (drawable);
 175   draw_impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
 176
 177   /* chain up */
 178   GDK_DRAWABLE_CLASS (parent_class)->set_colormap (drawable, cmap);
 179
 180   if (cmap)
 181     {
 182       /* XXX */
 183       g_print("gdk_window_impl_win32_set_colormap: XXX\n");
 184     }
 185 }
 186
 187 static void
 188 gdk_window_impl_win32_get_size (GdkDrawable *drawable,
 189                                 gint        *width,
 190                                 gint        *height)
 191 {
 192   g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable));
 193
 194   if (width)
 195     *width = GDK_WINDOW_IMPL_WIN32 (drawable)->width;
 196   if (height)
 197     *height = GDK_WINDOW_IMPL_WIN32 (drawable)->height;
 198 }
 199
 200 static GdkRegion*
 201 gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable)
 202 {
 203   GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (drawable);
 204   GdkRectangle result_rect;
 205
 206   result_rect.x = 0;
 207   result_rect.y = 0;
 208   result_rect.width = impl->width;
 209   result_rect.height = impl->height;
 210
 211   gdk_rectangle_intersect (&result_rect, &impl->position_info.clip_rect, &result_rect);
 212
 213   return gdk_region_rectangle (&result_rect);
 214 }
 215
 216 void
 217 _gdk_windowing_window_init (void)
 218 {
 219   GdkWindowObject *private;
 220   GdkWindowImplWin32 *impl;
 221   GdkDrawableImplWin32 *draw_impl;
 222   RECT rect;
 223   guint width;
 224   guint height;
 225
 226   g_assert (_gdk_parent_root == NULL);
 227
 228   SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);
 229   width  = rect.right - rect.left;
 230   height = rect.bottom - rect.top;
 231
 232   _gdk_parent_root = g_object_new (GDK_TYPE_WINDOW, NULL);
 233   private = (GdkWindowObject *)_gdk_parent_root;
 234   impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
 235   draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
 236
 237   draw_impl->handle = _gdk_root_window;
 238   draw_impl->wrapper = GDK_DRAWABLE (private);
 239   draw_impl->colormap = gdk_colormap_get_system ();
 240   gdk_colormap_ref (draw_impl->colormap);
 241
 242   private->window_type = GDK_WINDOW_ROOT;
 243   private->depth = gdk_visual_get_system ()->depth;
 244   impl->width = width;
 245   impl->height = height;
 246
 247   _gdk_window_init_position (GDK_WINDOW (private));
 248
 249   gdk_win32_handle_table_insert (&_gdk_root_window, _gdk_parent_root);
 250 }
 251
 252 static const gchar *
 253 get_default_title (void)
 254 {
 255   const char *title;
 256   title = g_get_application_name ();
 257   if (!title)
 258     title = g_get_prgname ();
 259
 260   return title;
 261 }
 262
 263 /* The Win API function AdjustWindowRect may return negative values
 264  * resulting in obscured title bars. This helper function is coreccting it.
 265  */
 266 static BOOL
 267 SafeAdjustWindowRectEx (RECT* lpRect,
 268                         DWORD dwStyle,
 269                         BOOL  bMenu,
 270                         DWORD dwExStyle)
 271 {
 272   if (!AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle))
 273     {
 274       WIN32_API_FAILED ("AdjustWindowRectEx");
 275       return FALSE;
 276     }
 277   if (lpRect->left < 0)
 278     {
 279       lpRect->right -= lpRect->left;
 280       lpRect->left = 0;
 281     }
 282   if (lpRect->top < 0)
 283     {
 284       lpRect->bottom -= lpRect->top;
 285       lpRect->top = 0;
 286     }
 287   return TRUE;
 288 }
 289
 290 /* RegisterGdkClass
 291  *   is a wrapper function for RegisterWindowClassEx.
 292  *   It creates at least one unique class for every
 293  *   GdkWindowType. If support for single window-specific icons
 294  *   is ever needed (e.g Dialog specific), every such window should
 295  *   get its own class
 296  */
 297 static ATOM
 298 RegisterGdkClass (GdkWindowType wtype)
 299 {
 300   static ATOM klassTOPLEVEL = 0;
 301   static ATOM klassDIALOG   = 0;
 302   static ATOM klassCHILD    = 0;
 303   static ATOM klassTEMP     = 0;
 304   static HICON hAppIcon = NULL;
 305   static WNDCLASSEX wcl;
 306   ATOM klass = 0;
 307
 308   wcl.cbSize = sizeof (WNDCLASSEX);
 309   wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
 310                   * on WM_SIZE and WM_MOVE. Flicker, Performance!
 311                   */
 312   wcl.lpfnWndProc = _gdk_win32_window_procedure;
 313   wcl.cbClsExtra = 0;
 314   wcl.cbWndExtra = 0;
 315   wcl.hInstance = _gdk_app_hmodule;
 316   wcl.hIcon = 0;
 317   /* initialize once! */
 318   if (0 == hAppIcon)
 319     {
 320       gchar sLoc [MAX_PATH+1];
 321
 322       if (0 != GetModuleFileName (_gdk_app_hmodule, sLoc, MAX_PATH))
 323         {
 324           hAppIcon = ExtractIcon (_gdk_app_hmodule, sLoc, 0);
 325           if (0 == hAppIcon)
 326             {
 327               if (0 != GetModuleFileName (_gdk_dll_hinstance, sLoc, MAX_PATH))
 328                 hAppIcon = ExtractIcon (_gdk_dll_hinstance, sLoc, 0);
 329             }
 330         }
 331       if (0 == hAppIcon)
 332         hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
 333     }
 334
 335   wcl.lpszMenuName = NULL;
 336   wcl.hIconSm = 0;
 337
 338   /* initialize once per class */
 339   /*
 340    * HB: Setting the background brush leads to flicker, because we
 341    * don't get asked how to clear the background. This is not what
 342    * we want, at least not for input_only windows ...
 343    */
 344 #define ONCE_PER_CLASS() \
 345   wcl.hIcon = CopyIcon (hAppIcon); \
 346   wcl.hIconSm = CopyIcon (hAppIcon); \
 347   wcl.hbrBackground = NULL; \
 348   wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
 349
 350   switch (wtype)
 351     {
 352     case GDK_WINDOW_TOPLEVEL:
 353       if (0 == klassTOPLEVEL)
 354         {
 355           wcl.lpszClassName = "gdkWindowToplevel";
 356
 357           ONCE_PER_CLASS();
 358           klassTOPLEVEL = RegisterClassEx (&wcl);
 359         }
 360       klass = klassTOPLEVEL;
 361       break;
 362
 363     case GDK_WINDOW_CHILD:
 364       if (0 == klassCHILD)
 365         {
 366           wcl.lpszClassName = "gdkWindowChild";
 367
 368           wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
 369           ONCE_PER_CLASS();
 370           klassCHILD = RegisterClassEx (&wcl);
 371         }
 372       klass = klassCHILD;
 373       break;
 374
 375     case GDK_WINDOW_DIALOG:
 376       if (0 == klassDIALOG)
 377         {
 378           wcl.lpszClassName = "gdkWindowDialog";
 379           wcl.style |= CS_SAVEBITS;
 380           ONCE_PER_CLASS();
 381           klassDIALOG = RegisterClassEx (&wcl);
 382         }
 383       klass = klassDIALOG;
 384       break;
 385
 386     case GDK_WINDOW_TEMP:
 387       if (0 == klassTEMP)
 388         {
 389           wcl.lpszClassName = "gdkWindowTemp";
 390           wcl.style |= CS_SAVEBITS;
 391           ONCE_PER_CLASS();
 392           klassTEMP = RegisterClassEx (&wcl);
 393         }
 394       klass = klassTEMP;
 395       break;
 396
 397     default:
 398       g_assert_not_reached ();
 399       break;
 400     }
 401
 402   if (klass == 0)
 403     {
 404       WIN32_API_FAILED ("RegisterClassEx");
 405       g_error ("That is a fatal error");
 406     }
 407   return klass;
 408 }
 409
 410 GdkWindow*
 411 gdk_window_new (GdkWindow     *parent,
 412                 GdkWindowAttr *attributes,
 413                 gint           attributes_mask)
 414 {
 415   HANDLE hparent;
 416   ATOM klass = 0;
 417   DWORD dwStyle, dwExStyle;
 418   RECT rect;
 419   GdkWindow *window;
 420   GdkWindowObject *private;
 421   GdkWindowImplWin32 *impl;
 422   GdkDrawableImplWin32 *draw_impl;
 423   GdkVisual *visual;
 424   int width, height;
 425   int x, y;
 426   char *title;
 427   char *mbtitle;
 428
 429   g_return_val_if_fail (attributes != NULL, NULL);
 430
 431   if (!parent)
 432     parent = _gdk_parent_root;
 433
 434   g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
 435
 436   GDK_NOTE (MISC,
 437             g_print ("gdk_window_new: %s\n",
 438                      (attributes->window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
 439                       (attributes->window_type == GDK_WINDOW_CHILD ? "CHILD" :
 440                        (attributes->window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
 441                         (attributes->window_type == GDK_WINDOW_TEMP ? "TEMP" :
 442                          "???"))))));
 443
 444   if (GDK_WINDOW_DESTROYED (parent))
 445     return NULL;
 446
 447   hparent = GDK_WINDOW_HWND (parent);
 448
 449   window = g_object_new (GDK_TYPE_WINDOW, NULL);
 450   private = (GdkWindowObject *)window;
 451   impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
 452   draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
 453   draw_impl->wrapper = GDK_DRAWABLE (window);
 454
 455   /* Windows with a foreign parent are treated as if they are children
 456    * of the root window, except for actual creation.
 457    */
 458   if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
 459     parent = _gdk_parent_root;
 460
 461   private->parent = (GdkWindowObject *)parent;
 462
 463   if (attributes_mask & GDK_WA_X)
 464     x = attributes->x;
 465   else
 466     x = CW_USEDEFAULT;
 467
 468   if (attributes_mask & GDK_WA_Y)
 469     y = attributes->y;
 470   else if (attributes_mask & GDK_WA_X)
 471     y = 100;                    /* ??? We must put it somewhere... */
 472   else
 473     y = 0;                      /* x is CW_USEDEFAULT, y doesn't matter then */
 474
 475   private->x = x;
 476   private->y = y;
 477   impl->width = (attributes->width > 1) ? (attributes->width) : (1);
 478   impl->height = (attributes->height > 1) ? (attributes->height) : (1);
 479   impl->extension_events_selected = FALSE;
 480   private->window_type = attributes->window_type;
 481
 482   _gdk_window_init_position (GDK_WINDOW (private));
 483   if (impl->position_info.big)
 484     private->guffaw_gravity = TRUE;
 485
 486   if (attributes_mask & GDK_WA_VISUAL)
 487     visual = attributes->visual;
 488   else
 489     visual = gdk_visual_get_system ();
 490
 491   if (attributes_mask & GDK_WA_TITLE)
 492     title = attributes->title;
 493   else
 494     title = get_default_title ();
 495   if (!title || !*title)
 496     title = "GDK client window";
 497
 498   private->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
 499
 500   if (private->parent && private->parent->guffaw_gravity)
 501     {
 502       /* XXX ??? */
 503     }
 504
 505   if (attributes->wclass == GDK_INPUT_OUTPUT)
 506     {
 507       dwExStyle = 0;
 508
 509       private->input_only = FALSE;
 510       private->depth = visual->depth;
 511
 512       if (attributes_mask & GDK_WA_COLORMAP)
 513         {
 514           draw_impl->colormap = attributes->colormap;
 515           gdk_colormap_ref (attributes->colormap);
 516         }
 517       else
 518         {
 519           draw_impl->colormap = gdk_colormap_get_system ();
 520         }
 521     }
 522   else
 523     {
 524       dwExStyle = WS_EX_TRANSPARENT;
 525       private->depth = 0;
 526       private->input_only = TRUE;
 527       draw_impl->colormap = gdk_colormap_get_system ();
 528       gdk_colormap_ref (draw_impl->colormap);
 529       GDK_NOTE (MISC, g_print ("...GDK_INPUT_ONLY, system colormap\n"));
 530     }
 531
 532   if (private->parent)
 533     private->parent->children = g_list_prepend (private->parent->children, window);
 534
 535   switch (private->window_type)
 536     {
 537     case GDK_WINDOW_TOPLEVEL:
 538       dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
 539       hparent = _gdk_root_window;
 540       break;
 541
 542     case GDK_WINDOW_CHILD:
 543       dwStyle = WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
 544       break;
 545
 546     case GDK_WINDOW_DIALOG:
 547       dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
 548 #if 0
 549       dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
 550 #endif
 551       hparent = _gdk_root_window;
 552       break;
 553
 554     case GDK_WINDOW_TEMP:
 555       dwStyle = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
 556       /* a temp window is not necessarily a top level window */
 557       dwStyle |= (_gdk_parent_root == parent ? WS_POPUP : WS_CHILDWINDOW);
 558       dwExStyle |= WS_EX_TOOLWINDOW;
 559       break;
 560
 561     case GDK_WINDOW_ROOT:
 562       g_error ("cannot make windows of type GDK_WINDOW_ROOT");
 563       break;
 564     }
 565
 566   klass = RegisterGdkClass (private->window_type);
 567
 568   if (private->window_type != GDK_WINDOW_CHILD)
 569     {
 570       if (x == CW_USEDEFAULT)
 571         {
 572           rect.left = 100;
 573           rect.top = 100;
 574         }
 575       else
 576         {
 577           rect.left = x;
 578           rect.top = y;
 579         }
 580
 581       rect.right = rect.left + impl->width;
 582       rect.bottom = rect.top + impl->height;
 583
 584       SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
 585
 586       if (x != CW_USEDEFAULT)
 587         {
 588           x = rect.left;
 589           y = rect.top;
 590         }
 591       width = rect.right - rect.left;
 592       height = rect.bottom - rect.top;
 593     }
 594   else
 595     {
 596       width = impl->width;
 597       height = impl->height;
 598     }
 599
 600   mbtitle = g_locale_from_utf8 (title, -1, NULL, NULL, NULL);
 601
 602 #ifdef WITHOUT_WM_CREATE
 603   draw_impl->handle = CreateWindowEx (dwExStyle,
 604                                       MAKEINTRESOURCE(klass),
 605                                       mbtitle,
 606                                       dwStyle,
 607                                       impl->position_info.x, impl->position_info.y,
 608                                       impl->position_info.width, impl->position_info.height,
 609                                       hparent,
 610                                       NULL,
 611                                       _gdk_app_hmodule,
 612                                       NULL);
 613 #else
 614   {
 615   HWND hwndNew =
 616     CreateWindowEx (dwExStyle,
 617                     MAKEINTRESOURCE(klass),
 618                     mbtitle,
 619                     dwStyle,
 620                     impl->position_info.x, impl->position_info.y,
 621                     impl->position_info.width, impl->position_info.height,
 622                     hparent,
 623                     NULL,
 624                     _gdk_app_hmodule,
 625                     window);
 626   if (GDK_WINDOW_HWND (window) != hwndNew)
 627     {
 628       g_warning("gdk_window_new: gdk_event_translate::WM_CREATE (%p, %p) HWND mismatch.",
 629                 GDK_WINDOW_HWND (window),
 630                 hwndNew);
 631
 632       /* HB: IHMO due to a race condition the handle was increased by
 633        * one, which causes much trouble. Because I can't find the
 634        * real bug, try to workaround it ...
 635        * To reproduce: compile with MSVC 5, DEBUG=1
 636        */
 637 # if 0
 638       gdk_win32_handle_table_remove (GDK_WINDOW_HWND (window));
 639       GDK_WINDOW_HWND (window) = hwndNew;
 640       gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
 641 # else
 642       /* the old behaviour, but with warning */
 643       GDK_WINDOW_HWND (window) = hwndNew;
 644 # endif
 645
 646     }
 647   }
 648   gdk_drawable_ref (window);
 649   gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
 650 #endif
 651
 652   GDK_NOTE (MISC,
 653             g_print ("... \"%s\" %dx%d@+%d+%d %p = %p\n",
 654                      mbtitle,
 655                      width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
 656                      hparent,
 657                      GDK_WINDOW_HWND (window)));
 658
 659   g_free (mbtitle);
 660
 661   if (draw_impl->handle == NULL)
 662     {
 663       WIN32_API_FAILED ("CreateWindowEx");
 664       g_object_unref ((GObject *) window);
 665       return NULL;
 666     }
 667
 668 #ifdef WITHOUT_WM_CREATE
 669   gdk_drawable_ref (window);
 670   gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
 671 #endif
 672
 673   gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
 674                                   (attributes->cursor) :
 675                                   NULL));
 676
 677   return window;
 678 }
 679
 680 GdkWindow *
 681 gdk_window_foreign_new_for_display (GdkDisplay      *display,
 682                                     GdkNativeWindow  anid)
 683 {
 684   GdkWindow *window;
 685   GdkWindowObject *private;
 686   GdkWindowImplWin32 *impl;
 687   GdkDrawableImplWin32 *draw_impl;
 688
 689   HANDLE parent;
 690   RECT rect;
 691   POINT point;
 692
 693   g_return_val_if_fail (display == gdk_display_get_default (), NULL);
 694
 695   window = g_object_new (GDK_TYPE_WINDOW, NULL);
 696   private = (GdkWindowObject *)window;
 697   impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
 698   draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
 699   draw_impl->wrapper = GDK_DRAWABLE (window);
 700   parent = GetParent ((HWND)anid);
 701
 702   private->parent = gdk_win32_handle_table_lookup ((GdkNativeWindow) parent);
 703   if (!private->parent || GDK_WINDOW_TYPE (private->parent) == GDK_WINDOW_FOREIGN)
 704     private->parent = (GdkWindowObject *)_gdk_parent_root;
 705
 706   private->parent->children = g_list_prepend (private->parent->children, window);
 707
 708   draw_impl->handle = (HWND) anid;
 709   GetClientRect ((HWND) anid, &rect);
 710   point.x = rect.left;
 711   point.y = rect.right;
 712   ClientToScreen ((HWND) anid, &point);
 713   if (parent != _gdk_root_window)
 714     ScreenToClient (parent, &point);
 715   private->x = point.x;
 716   private->y = point.y;
 717   impl->width = rect.right - rect.left;
 718   impl->height = rect.bottom - rect.top;
 719   private->window_type = GDK_WINDOW_FOREIGN;
 720   private->destroyed = FALSE;
 721   private->event_mask = GDK_ALL_EVENTS_MASK; /* XXX */
 722   if (IsWindowVisible ((HWND) anid))
 723     private->state &= (~GDK_WINDOW_STATE_WITHDRAWN);
 724   else
 725     private->state |= GDK_WINDOW_STATE_WITHDRAWN;
 726   private->depth = gdk_visual_get_system ()->depth;
 727
 728   _gdk_window_init_position (GDK_WINDOW (private));
 729
 730   gdk_drawable_ref (window);
 731   gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
 732
 733   return window;
 734 }
 735
 736 GdkWindow*
 737 gdk_window_lookup (GdkNativeWindow hwnd)
 738 {
 739   return (GdkWindow*) gdk_win32_handle_table_lookup (hwnd);
 740 }
 741
 742 void
 743 _gdk_windowing_window_destroy (GdkWindow *window,
 744                                gboolean   recursing,
 745                                gboolean   foreign_destroy)
 746 {
 747   GdkWindowObject *private = (GdkWindowObject *)window;
 748
 749   g_return_if_fail (GDK_IS_WINDOW (window));
 750
 751   GDK_NOTE (MISC, g_print ("_gdk_windowing_window_destroy %p\n",
 752                            GDK_WINDOW_HWND (window)));
 753
 754   if (private->extension_events != 0)
 755     _gdk_input_window_destroy (window);
 756
 757   if (private->window_type == GDK_WINDOW_FOREIGN)
 758     {
 759       if (!foreign_destroy && (private->parent != NULL))
 760         {
 761           /* It's somebody else's window, but in our hierarchy,
 762            * so reparent it to the root window, and then call
 763            * DestroyWindow() on it.
 764            */
 765           gdk_window_hide (window);
 766           gdk_window_reparent (window, NULL, 0, 0);
 767
 768           /* Is this too drastic? Many (most?) applications
 769            * quit if any window receives WM_QUIT I think.
 770            * OTOH, I don't think foreign windows are much
 771            * used, so the question is maybe academic.
 772            */
 773           PostMessage (GDK_WINDOW_HWND (window), WM_QUIT, 0, 0);
 774         }
 775     }
 776   else if (!recursing && !foreign_destroy)
 777     {
 778       private->destroyed = TRUE;
 779       DestroyWindow (GDK_WINDOW_HWND (window));
 780     }
 781 }
 782
 783 /* This function is called when the window really gone.
 784  */
 785 void
 786 gdk_window_destroy_notify (GdkWindow *window)
 787 {
 788   g_return_if_fail (window != NULL);
 789   g_return_if_fail (GDK_IS_WINDOW (window));
 790
 791   GDK_NOTE (EVENTS,
 792             g_print ("gdk_window_destroy_notify: %p  %s\n",
 793                      GDK_WINDOW_HWND (window),
 794                      (GDK_WINDOW_DESTROYED (window) ? "(destroyed)" : "")));
 795
 796   if (!GDK_WINDOW_DESTROYED (window))
 797     {
 798       if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
 799         g_warning ("window %p unexpectedly destroyed",
 800                    GDK_WINDOW_HWND (window));
 801
 802       _gdk_window_destroy (window, TRUE);
 803     }
 804
 805   gdk_win32_handle_table_remove (GDK_WINDOW_HWND (window));
 806   gdk_drawable_unref (window);
 807 }
 808
 809 static void
 810 show_window_internal (GdkWindow *window,
 811                       gboolean   raise,
 812                       gboolean   deiconify)
 813 {
 814   GdkWindowObject *private;
 815   HWND old_active_window;
 816
 817   private = GDK_WINDOW_OBJECT (window);
 818
 819   if (private->destroyed)
 820     return;
 821
 822   GDK_NOTE (MISC, g_print ("show_window_internal: %p %s%s%s\n",
 823                            GDK_WINDOW_HWND (window),
 824                            _gdk_win32_window_state_to_string (private->state),
 825                            (raise ? " raise" : ""),
 826                            (deiconify ? " deiconify" : "")));
 827
 828   /* If asked to show (not deiconify) an withdrawn and iconified
 829    * window, do that.
 830    */
 831   if (!deiconify &&
 832       !GDK_WINDOW_IS_MAPPED (window) &&
 833       (private->state & GDK_WINDOW_STATE_ICONIFIED))
 834     {
 835       ShowWindow (GDK_WINDOW_HWND (window), SW_MINIMIZE);
 836       return;
 837     }
 838
 839   /* If asked to just show an iconified window, do nothing. */
 840   if (!deiconify && (private->state & GDK_WINDOW_STATE_ICONIFIED))
 841     return;
 842
 843   /* If asked to deiconify an already noniconified window, do
 844    * nothing. (Especially, don't cause the window to rise and
 845    * activate. There are different calls for that.)
 846    */
 847   if (deiconify && !(private->state & GDK_WINDOW_STATE_ICONIFIED))
 848     return;
 849
 850   /* If asked to show (but not raise) a window that is already
 851    * visible, do nothing.
 852    */
 853   if (!deiconify && !raise && IsWindowVisible (GDK_WINDOW_HWND (window)))
 854     return;
 855
 856   /* Other cases */
 857
 858   if (!GDK_WINDOW_IS_MAPPED (window))
 859     gdk_synthesize_window_state (window,
 860                                  GDK_WINDOW_STATE_WITHDRAWN,
 861                                  0);
 862   if (GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE) & WS_EX_TRANSPARENT)
 863     {
 864       /* Don't really know if this makes sense, can't remember whether
 865        * this case is handled like this because it is necessary, or
 866        * if this is just old crap.
 867        */
 868       SetWindowPos(GDK_WINDOW_HWND (window), HWND_TOP, 0, 0, 0, 0,
 869                    SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOMOVE | SWP_NOSIZE);
 870       return;
 871     }
 872
 873   old_active_window = GetActiveWindow ();
 874
 875   if (private->state & GDK_WINDOW_STATE_MAXIMIZED)
 876     ShowWindow (GDK_WINDOW_HWND (window), SW_MAXIMIZE);
 877   else if (private->state & GDK_WINDOW_STATE_ICONIFIED)
 878     ShowWindow (GDK_WINDOW_HWND (window), SW_RESTORE);
 879   else
 880     ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNORMAL);
 881
 882   if (raise)
 883     BringWindowToTop (GDK_WINDOW_HWND (window));
 884   else if (old_active_window != GDK_WINDOW_HWND (window))
 885     SetActiveWindow (old_active_window);
 886 }
 887
 888 void
 889 gdk_window_show_unraised (GdkWindow *window)
 890 {
 891   g_return_if_fail (GDK_IS_WINDOW (window));
 892
 893   show_window_internal (window, FALSE, FALSE);
 894 }
 895
 896 void
 897 gdk_window_show (GdkWindow *window)
 898 {
 899   g_return_if_fail (GDK_IS_WINDOW (window));
 900
 901   show_window_internal (window, TRUE, FALSE);
 902 }
 903
 904 void
 905 gdk_window_hide (GdkWindow *window)
 906 {
 907   GdkWindowObject *private;
 908
 909   g_return_if_fail (window != NULL);
 910
 911   private = (GdkWindowObject*) window;
 912   if (!private->destroyed)
 913     {
 914       GDK_NOTE (MISC, g_print ("gdk_window_hide: %p %s\n",
 915                                GDK_WINDOW_HWND (window),
 916                                _gdk_win32_window_state_to_string (private->state)));
 917
 918       if (GDK_WINDOW_IS_MAPPED (window))
 919         gdk_synthesize_window_state (window,
 920                                      0,
 921                                      GDK_WINDOW_STATE_WITHDRAWN);
 922
 923       _gdk_window_clear_update_area (window);
 924
 925       if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL)
 926         ShowOwnedPopups (GDK_WINDOW_HWND (window), FALSE);
 927
 928       if (GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE) & WS_EX_TRANSPARENT)
 929         {
 930           SetWindowPos(GDK_WINDOW_HWND (window), HWND_BOTTOM, 0, 0, 0, 0,
 931                        SWP_HIDEWINDOW | SWP_NOREDRAW | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE);
 932         }
 933       else
 934         {
 935           ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
 936         }
 937     }
 938 }
 939
 940 void
 941 gdk_window_withdraw (GdkWindow *window)
 942 {
 943   GdkWindowObject *private;
 944
 945   g_return_if_fail (window != NULL);
 946
 947   private = (GdkWindowObject*) window;
 948   if (!private->destroyed)
 949     {
 950       GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %p %s\n",
 951                                GDK_WINDOW_HWND (window),
 952                                _gdk_win32_window_state_to_string (private->state)));
 953
 954       gdk_window_hide (window); /* ??? */
 955     }
 956 }
 957
 958 void
 959 gdk_window_move (GdkWindow *window,
 960                  gint       x,
 961                  gint       y)
 962 {
 963   GdkWindowObject *private = (GdkWindowObject *)window;
 964   GdkWindowImplWin32 *impl;
 965
 966   g_return_if_fail (window != NULL);
 967   g_return_if_fail (GDK_IS_WINDOW (window));
 968
 969   impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
 970
 971   if (!GDK_WINDOW_DESTROYED (window))
 972     {
 973       if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
 974         _gdk_window_move_resize_child (window, x, y,
 975                                        impl->width, impl->height);
 976       else
 977         {
 978           if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL,
 979                              x, y, impl->width, impl->height,
 980                              SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER))
 981             WIN32_API_FAILED ("SetWindowPos");
 982         }
 983     }
 984 }
 985
 986 void
 987 gdk_window_resize (GdkWindow *window,
 988                    gint       width,
 989                    gint       height)
 990 {
 991   GdkWindowObject *private = (GdkWindowObject*) window;
 992   GdkWindowImplWin32 *impl;
 993   int x, y;
 994
 995   g_return_if_fail (window != NULL);
 996   g_return_if_fail (GDK_IS_WINDOW (window));
 997
 998   if (width < 1)
 999     width = 1;
1000   if (height < 1)
1001     height = 1;
1002
1003   impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
1004
1005   if (!GDK_WINDOW_DESTROYED (window))
1006     {
1007       if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
1008         _gdk_window_move_resize_child (window, private->x, private->y,
1009                                        width, height);
1010       else
1011         {
1012           POINT pt;
1013           RECT rect;
1014           DWORD dwStyle;
1015           DWORD dwExStyle;
1016
1017           pt.x = 0;
1018           pt.y = 0;
1019           ClientToScreen (GDK_WINDOW_HWND (window), &pt);
1020           rect.left = pt.x;
1021           rect.top = pt.y;
1022           rect.right = pt.x + width;
1023           rect.bottom = pt.y + height;
1024
1025           dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1026           dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1027           if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
1028             WIN32_API_FAILED ("AdjustWindowRectEx");
1029
1030           x = rect.left;
1031           y = rect.top;
1032           width = rect.right - rect.left;
1033           height = rect.bottom - rect.top;
1034           if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL,
1035                              x, y, width, height,
1036                              SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER))
1037             WIN32_API_FAILED ("SetWindowPos");
1038         }
1039       private->resize_count += 1;
1040     }
1041 }
1042
1043 void
1044 gdk_window_move_resize (GdkWindow *window,
1045                         gint       x,
1046                         gint       y,
1047                         gint       width,
1048                         gint       height)
1049 {
1050   GdkWindowObject *private = (GdkWindowObject*) window;
1051   GdkWindowImplWin32 *impl;
1052
1053   g_return_if_fail (window != NULL);
1054   g_return_if_fail (GDK_IS_WINDOW (window));
1055
1056   if (width < 1)
1057     width = 1;
1058   if (height < 1)
1059     height = 1;
1060
1061   impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
1062
1063   if (!private->destroyed)
1064     {
1065       RECT rect;
1066       DWORD dwStyle;
1067       DWORD dwExStyle;
1068
1069       GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %p %dx%d@+%d+%d\n",
1070                                GDK_WINDOW_HWND (window),
1071                                width, height, x, y));
1072
1073       if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
1074         _gdk_window_move_resize_child (window, x, y, width, height);
1075       else
1076         {
1077           rect.left = x;
1078           rect.top = y;
1079           rect.right = x + width;
1080           rect.bottom = y + height;
1081
1082           dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1083           dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1084           if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
1085             WIN32_API_FAILED ("AdjustWindowRectEx");
1086
1087           GDK_NOTE (MISC, g_print ("...SetWindowPos(%p,%ldx%ld@+%ld+%ld)\n",
1088                                    GDK_WINDOW_HWND (window),
1089                                    rect.right - rect.left, rect.bottom - rect.top,
1090                                    rect.left, rect.top));
1091           if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL,
1092                              rect.left, rect.top,
1093                              rect.right - rect.left, rect.bottom - rect.top,
1094                              SWP_NOACTIVATE | SWP_NOZORDER))
1095             WIN32_API_FAILED ("SetWindowPos");
1096         }
1097     }
1098 }
1099
1100 void
1101 gdk_window_reparent (GdkWindow *window,
1102                      GdkWindow *new_parent,
1103                      gint       x,
1104                      gint       y)
1105 {
1106   GdkWindowObject *window_private;
1107   GdkWindowObject *parent_private;
1108   GdkWindowObject *old_parent_private;
1109   GdkWindowImplWin32 *impl;
1110
1111   g_return_if_fail (window != NULL);
1112   g_return_if_fail (GDK_IS_WINDOW (window));
1113   g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
1114   g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
1115
1116   if (!new_parent)
1117     new_parent = _gdk_parent_root;
1118
1119   window_private = (GdkWindowObject*) window;
1120   old_parent_private = (GdkWindowObject *) window_private->parent;
1121   parent_private = (GdkWindowObject*) new_parent;
1122   impl = GDK_WINDOW_IMPL_WIN32 (window_private->impl);
1123
1124   if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (new_parent))
1125     {
1126       GDK_NOTE (MISC, g_print ("gdk_window_reparent: %p %p\n",
1127                                GDK_WINDOW_HWND (window),
1128                                GDK_WINDOW_HWND (new_parent)));
1129       if (!SetParent (GDK_WINDOW_HWND (window),
1130                       GDK_WINDOW_HWND (new_parent)))
1131         WIN32_API_FAILED ("SetParent");
1132
1133       if (!MoveWindow (GDK_WINDOW_HWND (window),
1134                        x, y, impl->width, impl->height, TRUE))
1135         WIN32_API_FAILED ("MoveWindow");
1136     }
1137
1138   /* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
1139    * the root window
1140    */
1141   if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
1142     new_parent = _gdk_parent_root;
1143
1144   window_private->parent = (GdkWindowObject *)new_parent;
1145
1146   if (old_parent_private)
1147     old_parent_private->children =
1148       g_list_remove (old_parent_private->children, window);
1149
1150 #if 0
1151   if ((old_parent_private &&
1152        (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
1153       (!old_parent_private && parent_private->guffaw_gravity))
1154     gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
1155 #endif
1156
1157   parent_private->children = g_list_prepend (parent_private->children, window);
1158   _gdk_window_init_position (GDK_WINDOW (window_private));
1159 }
1160
1161 void
1162 _gdk_windowing_window_clear_area (GdkWindow *window,
1163                                   gint       x,
1164                                   gint       y,
1165                                   gint       width,
1166                                   gint       height)
1167 {
1168   GdkWindowImplWin32 *impl;
1169
1170   g_return_if_fail (window != NULL);
1171   g_return_if_fail (GDK_IS_WINDOW (window));
1172
1173   impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1174
1175   if (!GDK_WINDOW_DESTROYED (window))
1176     {
1177       HDC hdc;
1178
1179       if (width == 0)
1180         width = impl->width - x;
1181       if (height == 0)
1182         height = impl->height - y;
1183       GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area: "
1184                                "%p %dx%d@+%d+%d\n",
1185                                GDK_WINDOW_HWND (window),
1186                                width, height, x, y));
1187       hdc = GetDC (GDK_WINDOW_HWND (window));
1188       IntersectClipRect (hdc, x, y, x + width + 1, y + height + 1);
1189       SendMessage (GDK_WINDOW_HWND (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
1190       if (!ReleaseDC (GDK_WINDOW_HWND (window), hdc))
1191         WIN32_GDI_FAILED ("ReleaseDC");
1192     }
1193 }
1194
1195 void
1196 _gdk_windowing_window_clear_area_e (GdkWindow *window,
1197                                     gint       x,
1198                                     gint       y,
1199                                     gint       width,
1200                                     gint       height)
1201 {
1202   g_return_if_fail (window != NULL);
1203   g_return_if_fail (GDK_IS_WINDOW (window));
1204
1205   if (!GDK_WINDOW_DESTROYED (window))
1206     {
1207       RECT rect;
1208
1209       GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area_e: "
1210                                "%p %dx%d@+%d+%d\n",
1211                                GDK_WINDOW_HWND (window),
1212                                width, height, x, y));
1213
1214       rect.left = x;
1215       rect.right = x + width + 1;
1216       rect.top = y;
1217       rect.bottom = y + height + 1;
1218       if (!InvalidateRect (GDK_WINDOW_HWND (window), &rect, TRUE))
1219         WIN32_GDI_FAILED ("InvalidateRect");
1220       UpdateWindow (GDK_WINDOW_HWND (window));
1221     }
1222 }
1223
1224 void
1225 gdk_window_raise (GdkWindow *window)
1226 {
1227   g_return_if_fail (window != NULL);
1228   g_return_if_fail (GDK_IS_WINDOW (window));
1229
1230   if (!GDK_WINDOW_DESTROYED (window))
1231     {
1232       GDK_NOTE (MISC, g_print ("gdk_window_raise: %p\n",
1233                                GDK_WINDOW_HWND (window)));
1234
1235       if (!BringWindowToTop (GDK_WINDOW_HWND (window)))
1236         WIN32_API_FAILED ("BringWindowToTop");
1237     }
1238 }
1239
1240 void
1241 gdk_window_lower (GdkWindow *window)
1242 {
1243   g_return_if_fail (window != NULL);
1244   g_return_if_fail (GDK_IS_WINDOW (window));
1245
1246   if (!GDK_WINDOW_DESTROYED (window))
1247     {
1248       GDK_NOTE (MISC, g_print ("gdk_window_lower: %p\n",
1249                                GDK_WINDOW_HWND (window)));
1250
1251       if (!SetWindowPos (GDK_WINDOW_HWND (window), HWND_BOTTOM, 0, 0, 0, 0,
1252                          SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
1253         WIN32_API_FAILED ("SetWindowPos");
1254     }
1255 }
1256
1257 void
1258 gdk_window_set_hints (GdkWindow *window,
1259                       gint       x,
1260                       gint       y,
1261                       gint       min_width,
1262                       gint       min_height,
1263                       gint       max_width,
1264                       gint       max_height,
1265                       gint       flags)
1266 {
1267   GdkWindowImplWin32 *impl;
1268   WINDOWPLACEMENT size_hints;
1269   RECT rect;
1270   DWORD dwStyle;
1271   DWORD dwExStyle;
1272   int diff;
1273
1274   g_return_if_fail (window != NULL);
1275   g_return_if_fail (GDK_IS_WINDOW (window));
1276
1277   if (GDK_WINDOW_DESTROYED (window))
1278     return;
1279
1280   impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1281
1282   GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %p %dx%d..%dx%d @+%d+%d\n",
1283                            GDK_WINDOW_HWND (window),
1284                            min_width, min_height, max_width, max_height,
1285                            x, y));
1286
1287   impl->hint_flags = flags;
1288   size_hints.length = sizeof (size_hints);
1289
1290   if (flags)
1291     {
1292       GdkGeometry geom;
1293       gint        geom_mask = 0;
1294
1295       geom.min_width  = min_width;
1296       geom.min_height = min_height;
1297       geom.max_width  = max_width;
1298       geom.max_height = max_height;
1299
1300       if (flags & GDK_HINT_POS)
1301         {
1302           if (!GetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1303             WIN32_API_FAILED ("GetWindowPlacement");
1304           else
1305             {
1306               GDK_NOTE (MISC, g_print ("...rcNormalPosition:"
1307                                        " (%ld,%ld)--(%ld,%ld)\n",
1308                                        size_hints.rcNormalPosition.left,
1309                                        size_hints.rcNormalPosition.top,
1310                                        size_hints.rcNormalPosition.right,
1311                                        size_hints.rcNormalPosition.bottom));
1312               /* What are the corresponding window coordinates for client
1313                * area coordinates x, y
1314                */
1315               rect.left = x;
1316               rect.top = y;
1317               rect.right = rect.left + 200;     /* dummy */
1318               rect.bottom = rect.top + 200;
1319               dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1320               dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1321               AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1322               size_hints.flags = 0;
1323               size_hints.showCmd = SW_SHOWNA;
1324
1325               /* Set the normal position hint to that location, with unchanged
1326                * width and height.
1327                */
1328               diff = size_hints.rcNormalPosition.left - rect.left;
1329               size_hints.rcNormalPosition.left = rect.left;
1330               size_hints.rcNormalPosition.right -= diff;
1331               diff = size_hints.rcNormalPosition.top - rect.top;
1332               size_hints.rcNormalPosition.top = rect.top;
1333               size_hints.rcNormalPosition.bottom -= diff;
1334               GDK_NOTE (MISC, g_print ("...setting: (%ld,%ld)--(%ld,%ld)\n",
1335                                        size_hints.rcNormalPosition.left,
1336                                        size_hints.rcNormalPosition.top,
1337                                        size_hints.rcNormalPosition.right,
1338                                        size_hints.rcNormalPosition.bottom));
1339               if (!SetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1340                 WIN32_API_FAILED ("SetWindowPlacement");
1341               impl->hint_x = rect.left;
1342               impl->hint_y = rect.top;
1343             }
1344         }
1345
1346       if (flags & GDK_HINT_MIN_SIZE)
1347         geom_mask |= GDK_HINT_MIN_SIZE;
1348
1349       if (flags & GDK_HINT_MAX_SIZE)
1350         geom_mask |= GDK_HINT_MAX_SIZE;
1351
1352       gdk_window_set_geometry_hints (window, &geom, geom_mask);
1353     }
1354 }
1355
1356 void
1357 gdk_window_set_geometry_hints (GdkWindow      *window,
1358                                GdkGeometry    *geometry,
1359                                GdkWindowHints  geom_mask)
1360 {
1361   GdkWindowImplWin32 *impl;
1362   WINDOWPLACEMENT size_hints;
1363   RECT rect;
1364   DWORD dwStyle;
1365   DWORD dwExStyle;
1366   gint new_width = 0, new_height = 0;
1367
1368   g_return_if_fail (window != NULL);
1369   g_return_if_fail (GDK_IS_WINDOW (window));
1370
1371   if (GDK_WINDOW_DESTROYED (window))
1372     return;
1373
1374   impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1375   size_hints.length = sizeof (size_hints);
1376
1377   impl->hint_flags = geom_mask;
1378
1379   if (geom_mask & GDK_HINT_POS)
1380     ; /* even the X11 mplementation doesn't care */
1381
1382   if (geom_mask & GDK_HINT_MIN_SIZE)
1383     {
1384       rect.left = 0;
1385       rect.top = 0;
1386       rect.right = geometry->min_width;
1387       rect.bottom = geometry->min_height;
1388       dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1389       dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1390       AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1391       impl->hint_min_width = rect.right - rect.left;
1392       impl->hint_min_height = rect.bottom - rect.top;
1393
1394       /* Also check if he current size of the window is in bounds */
1395       GetClientRect (GDK_WINDOW_HWND (window), &rect);
1396
1397       if (rect.right < geometry->min_width
1398           && rect.bottom < geometry->min_height)
1399         {
1400           new_width = geometry->min_width; new_height = geometry->min_height;
1401         }
1402       else if (rect.right < geometry->min_width)
1403         {
1404           new_width = geometry->min_width; new_height = rect.bottom;
1405         }
1406       else if (rect.bottom < geometry->min_height)
1407         {
1408           new_width = rect.right; new_height = geometry->min_height;
1409         }
1410     }
1411
1412   if (geom_mask & GDK_HINT_MAX_SIZE)
1413     {
1414       rect.left = 0;
1415       rect.top = 0;
1416       rect.right = geometry->max_width;
1417       rect.bottom = geometry->max_height;
1418       dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1419       dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1420       /* HB: dont' know why AdjustWindowRectEx is called here, ... */
1421       SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1422       impl->hint_max_width = rect.right - rect.left;
1423       impl->hint_max_height = rect.bottom - rect.top;
1424       /* ... but negative sizes are always wrong */
1425       if (impl->hint_max_width < 0) impl->hint_max_width = G_MAXSHORT;
1426       if (impl->hint_max_height < 0) impl->hint_max_height = G_MAXSHORT;
1427
1428       /* Again, check if the window is too large currently. */
1429       GetClientRect (GDK_WINDOW_HWND (window), &rect);
1430       if (rect.right > geometry->max_width
1431           && rect.bottom > geometry->max_height)
1432         {
1433           new_width = geometry->max_width; new_height = geometry->max_height;
1434         }
1435       else if (rect.right > geometry->max_width)
1436         {
1437           new_width = geometry->max_width; new_height = rect.bottom;
1438         }
1439       else if (rect.bottom > geometry->max_height)
1440         {
1441           new_width = rect.right; new_height = geometry->max_height;
1442         }
1443     }
1444
1445   /* finally apply new size constraints */
1446   if (new_width != 0 && new_height != 0)
1447     gdk_window_resize (window, new_width, new_height);
1448
1449   /* I don't know what to do when called with zero base_width and height. */
1450   if (geom_mask & GDK_HINT_BASE_SIZE
1451       && geometry->base_width > 0
1452       && geometry->base_height > 0)
1453     {
1454       if (!GetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1455         WIN32_API_FAILED ("GetWindowPlacement");
1456       else
1457         {
1458           GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
1459                                    " rcNormalPosition: (%ld,%ld)--(%ld,%ld)\n",
1460                                    size_hints.rcNormalPosition.left,
1461                                    size_hints.rcNormalPosition.top,
1462                                    size_hints.rcNormalPosition.right,
1463                                    size_hints.rcNormalPosition.bottom));
1464           size_hints.rcNormalPosition.right =
1465             size_hints.rcNormalPosition.left + geometry->base_width;
1466           size_hints.rcNormalPosition.bottom =
1467             size_hints.rcNormalPosition.top + geometry->base_height;
1468           GDK_NOTE (MISC, g_print ("...setting: rcNormal: (%ld,%ld)--(%ld,%ld)\n",
1469                                    size_hints.rcNormalPosition.left,
1470                                    size_hints.rcNormalPosition.top,
1471                                    size_hints.rcNormalPosition.right,
1472                                    size_hints.rcNormalPosition.bottom));
1473           if (!SetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1474             WIN32_API_FAILED ("SetWindowPlacement");
1475         }
1476     }
1477
1478   if (geom_mask & GDK_HINT_RESIZE_INC)
1479     {
1480       /* XXX */
1481     }
1482
1483   if (geom_mask & GDK_HINT_ASPECT)
1484     {
1485       /* XXX */
1486     }
1487 }
1488
1489 void
1490 gdk_window_set_title (GdkWindow   *window,
1491                       const gchar *title)
1492 {
1493   char *mbtitle;
1494
1495   g_return_if_fail (window != NULL);
1496   g_return_if_fail (GDK_IS_WINDOW (window));
1497   g_return_if_fail (title != NULL);
1498
1499   /* Empty window titles not allowed, so set it to just a period. */
1500   if (!title[0])
1501     title = ".";
1502
1503   GDK_NOTE (MISC, g_print ("gdk_window_set_title: %p %s\n",
1504                            GDK_WINDOW_HWND (window), title));
1505
1506   if (!GDK_WINDOW_DESTROYED (window))
1507     {
1508       /* As the title is in UTF-8 we must translate it
1509        * to the system codepage.
1510        */
1511       mbtitle = g_locale_from_utf8 (title, -1, NULL, NULL, NULL);
1512       if (!SetWindowText (GDK_WINDOW_HWND (window), mbtitle))
1513         WIN32_API_FAILED ("SetWindowText");
1514
1515       g_free (mbtitle);
1516     }
1517 }
1518
1519 void
1520 gdk_window_set_role (GdkWindow   *window,
1521                      const gchar *role)
1522 {
1523   g_return_if_fail (window != NULL);
1524   g_return_if_fail (GDK_IS_WINDOW (window));
1525
1526   GDK_NOTE (MISC, g_print ("gdk_window_set_role: %p %s\n",
1527                            GDK_WINDOW_HWND (window),
1528                            (role ? role : "NULL")));
1529   /* XXX */
1530 }
1531
1532 void
1533 gdk_window_set_transient_for (GdkWindow *window,
1534                               GdkWindow *parent)
1535 {
1536   HWND window_id, parent_id;
1537
1538   g_return_if_fail (window != NULL);
1539   g_return_if_fail (GDK_IS_WINDOW (window));
1540
1541   GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %p %p\n",
1542                            GDK_WINDOW_HWND (window),
1543                            GDK_WINDOW_HWND (parent)));
1544
1545   if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (parent))
1546     return;
1547
1548   if (((GdkWindowObject *) window)->window_type == GDK_WINDOW_CHILD)
1549     {
1550       GDK_NOTE (MISC, g_print ("...a child window!\n"));
1551       return;
1552     }
1553
1554   window_id = GDK_WINDOW_HWND (window);
1555   parent_id = GDK_WINDOW_HWND (parent);
1556
1557   /* This changes the *owner* of the window, despite the misleading
1558    * name. (Owner and parent are unrelated concepts.) At least that's
1559    * what people who seem to know what they talk about say on
1560    * USENET. Search on Google.
1561    */
1562   SetLastError (0);
1563   if (SetWindowLong (window_id, GWL_HWNDPARENT, (long) parent_id) == 0 &&
1564       GetLastError () != 0)
1565     WIN32_API_FAILED ("SetWindowLong");
1566 }
1567
1568 void
1569 gdk_window_set_background (GdkWindow *window,
1570                            GdkColor  *color)
1571 {
1572   GdkWindowObject *private = (GdkWindowObject *)window;
1573
1574   g_return_if_fail (window != NULL);
1575   g_return_if_fail (GDK_IS_WINDOW (window));
1576
1577   GDK_NOTE (MISC, g_print ("gdk_window_set_background: %p %s\n",
1578                            GDK_WINDOW_HWND (window),
1579                            _gdk_win32_color_to_string (color)));
1580
1581   private->bg_color = *color;
1582
1583   if (private->bg_pixmap &&
1584       private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1585       private->bg_pixmap != GDK_NO_BG)
1586     {
1587       gdk_drawable_unref (private->bg_pixmap);
1588       private->bg_pixmap = NULL;
1589     }
1590 }
1591
1592 void
1593 gdk_window_set_back_pixmap (GdkWindow *window,
1594                             GdkPixmap *pixmap,
1595                             gint       parent_relative)
1596 {
1597   GdkWindowObject *private = (GdkWindowObject *)window;
1598
1599   g_return_if_fail (window != NULL);
1600   g_return_if_fail (GDK_IS_WINDOW (window));
1601   g_return_if_fail (pixmap == NULL || !parent_relative);
1602   g_return_if_fail (pixmap == NULL || gdk_drawable_get_depth (window) == gdk_drawable_get_depth (pixmap));
1603
1604   if (private->bg_pixmap &&
1605       private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1606       private->bg_pixmap != GDK_NO_BG)
1607     gdk_drawable_unref (private->bg_pixmap);
1608
1609   if (parent_relative)
1610     {
1611       private->bg_pixmap = GDK_PARENT_RELATIVE_BG;
1612       GDK_NOTE (MISC, g_print (G_STRLOC ": setting background pixmap to parent_relative\n"));
1613     }
1614   else
1615     {
1616       if (pixmap)
1617         {
1618           gdk_drawable_ref (pixmap);
1619           private->bg_pixmap = pixmap;
1620         }
1621       else
1622         {
1623           private->bg_pixmap = GDK_NO_BG;
1624         }
1625     }
1626 }
1627
1628 void
1629 gdk_window_set_cursor (GdkWindow *window,
1630                        GdkCursor *cursor)
1631 {
1632   GdkWindowImplWin32 *impl;
1633   GdkCursorPrivate *cursor_private;
1634   GdkWindowObject *parent_window;
1635   HCURSOR hcursor;
1636   HCURSOR hprevcursor;
1637
1638   g_return_if_fail (window != NULL);
1639   g_return_if_fail (GDK_IS_WINDOW (window));
1640
1641   impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1642   cursor_private = (GdkCursorPrivate*) cursor;
1643
1644   if (GDK_WINDOW_DESTROYED (window))
1645     return;
1646
1647   if (!cursor)
1648     hcursor = NULL;
1649   else
1650     hcursor = cursor_private->hcursor;
1651
1652   GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %p %p\n",
1653                            GDK_WINDOW_HWND (window),
1654                            hcursor));
1655
1656   /* First get the old cursor, if any (we wait to free the old one
1657    * since it may be the current cursor set in the Win32 API right
1658    * now).
1659    */
1660   hprevcursor = impl->hcursor;
1661
1662   if (hcursor == NULL)
1663     impl->hcursor = NULL;
1664   else
1665     {
1666       /* We must copy the cursor as it is OK to destroy the GdkCursor
1667        * while still in use for some window. See for instance
1668        * gimp_change_win_cursor() which calls gdk_window_set_cursor
1669        * (win, cursor), and immediately afterwards gdk_cursor_destroy
1670        * (cursor).
1671        */
1672       if ((impl->hcursor = CopyCursor (hcursor)) == NULL)
1673         WIN32_API_FAILED ("CopyCursor");
1674       GDK_NOTE (MISC, g_print ("...CopyCursor (%p) = %p\n",
1675                                hcursor, impl->hcursor));
1676     }
1677
1678   /* If the pointer is over our window, set new cursor if given */
1679   if (gdk_window_get_pointer(window, NULL, NULL, NULL) == window)
1680     if (impl->hcursor != NULL)
1681       SetCursor (impl->hcursor);
1682
1683   /* Destroy the previous cursor: Need to make sure it's no longer in
1684    * use before we destroy it, in case we're not over our window but
1685    * the cursor is still set to our old one.
1686    */
1687   if (hprevcursor != NULL)
1688     {
1689       if (GetCursor() == hprevcursor)
1690         {
1691           /* Look for a suitable cursor to use instead */
1692           hcursor = NULL;
1693           parent_window = GDK_WINDOW_OBJECT (window)->parent;
1694           while (hcursor == NULL)
1695             {
1696               if (parent_window)
1697                 {
1698                   impl = GDK_WINDOW_IMPL_WIN32 (parent_window->impl);
1699                   hcursor = impl->hcursor;
1700                   parent_window = parent_window->parent;
1701                 }
1702               else
1703                 {
1704                   hcursor = LoadCursor (NULL, IDC_ARROW);
1705                 }
1706             }
1707           SetCursor (hcursor);
1708         }
1709
1710       GDK_NOTE (MISC, g_print ("...DestroyCursor (%p)\n",
1711                                hprevcursor));
1712
1713       if (!DestroyCursor (hprevcursor))
1714         WIN32_API_FAILED ("DestroyCursor");
1715     }
1716 }
1717
1718 void
1719 gdk_window_get_geometry (GdkWindow *window,
1720                          gint      *x,
1721                          gint      *y,
1722                          gint      *width,
1723                          gint      *height,
1724                          gint      *depth)
1725 {
1726   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1727
1728   if (!window)
1729     window = _gdk_parent_root;
1730
1731   if (!GDK_WINDOW_DESTROYED (window))
1732     {
1733       RECT rect;
1734
1735       if (!GetClientRect (GDK_WINDOW_HWND (window), &rect))
1736         WIN32_API_FAILED ("GetClientRect");
1737
1738       if (window != _gdk_parent_root)
1739         {
1740           POINT pt;
1741           GdkWindow *parent = gdk_window_get_parent (window);
1742
1743           pt.x = rect.left;
1744           pt.y = rect.top;
1745           ClientToScreen (GDK_WINDOW_HWND (window), &pt);
1746           ScreenToClient (GDK_WINDOW_HWND (parent), &pt);
1747           rect.left = pt.x;
1748           rect.top = pt.y;
1749
1750           pt.x = rect.right;
1751           pt.y = rect.bottom;
1752           ClientToScreen (GDK_WINDOW_HWND (window), &pt);
1753           ScreenToClient (GDK_WINDOW_HWND (parent), &pt);
1754           rect.right = pt.x;
1755           rect.bottom = pt.y;
1756         }
1757
1758       if (x)
1759         *x = rect.left;
1760       if (y)
1761         *y = rect.top;
1762       if (width)
1763         *width = rect.right - rect.left;
1764       if (height)
1765         *height = rect.bottom - rect.top;
1766       if (depth)
1767         *depth = gdk_drawable_get_visual (window)->depth;
1768     }
1769 }
1770
1771 gint
1772 gdk_window_get_origin (GdkWindow *window,
1773                        gint      *x,
1774                        gint      *y)
1775 {
1776   gint return_val;
1777   gint tx = 0;
1778   gint ty = 0;
1779
1780   g_return_val_if_fail (window != NULL, 0);
1781
1782   if (!GDK_WINDOW_DESTROYED (window))
1783     {
1784       POINT pt;
1785
1786       pt.x = 0;
1787       pt.y = 0;
1788       ClientToScreen (GDK_WINDOW_HWND (window), &pt);
1789       tx = pt.x;
1790       ty = pt.y;
1791       return_val = 1;
1792     }
1793   else
1794     return_val = 0;
1795
1796   if (x)
1797     *x = tx;
1798   if (y)
1799     *y = ty;
1800
1801   GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %p: +%d+%d\n",
1802                            GDK_WINDOW_HWND (window),
1803                            tx, ty));
1804   return return_val;
1805 }
1806
1807 gboolean
1808 gdk_window_get_deskrelative_origin (GdkWindow *window,
1809                                     gint      *x,
1810                                     gint      *y)
1811 {
1812   return gdk_window_get_origin (window, x, y);
1813 }
1814
1815 void
1816 gdk_window_get_root_origin (GdkWindow *window,
1817                             gint      *x,
1818                             gint      *y)
1819 {
1820   GdkRectangle rect;
1821
1822   g_return_if_fail (GDK_IS_WINDOW (window));
1823
1824   gdk_window_get_frame_extents (window, &rect);
1825
1826   if (x)
1827     *x = rect.x;
1828
1829   if (y)
1830     *y = rect.y;
1831 }
1832
1833 void
1834 gdk_window_get_frame_extents (GdkWindow    *window,
1835                               GdkRectangle *rect)
1836 {
1837   GdkWindowObject *private;
1838   HWND hwnd;
1839   RECT r;
1840
1841   g_return_if_fail (GDK_IS_WINDOW (window));
1842   g_return_if_fail (rect != NULL);
1843
1844   private = GDK_WINDOW_OBJECT (window);
1845
1846   rect->x = 0;
1847   rect->y = 0;
1848   rect->width = 1;
1849   rect->height = 1;
1850
1851   if (GDK_WINDOW_DESTROYED (window))
1852     return;
1853
1854   while (private->parent && ((GdkWindowObject*) private->parent)->parent)
1855     private = (GdkWindowObject*) private->parent;
1856
1857   hwnd = GDK_WINDOW_HWND (window);
1858
1859   /* find the frame window */
1860   while (HWND_DESKTOP != GetParent (hwnd))
1861     {
1862       hwnd = GetParent (hwnd);
1863       g_return_if_fail (NULL != hwnd);
1864     }
1865
1866   if (!GetWindowRect (hwnd, &r))
1867     WIN32_API_FAILED ("GetWindowRect");
1868
1869   rect->x = r.left;
1870   rect->y = r.top;
1871   rect->width = r.right - r.left;
1872   rect->height = r.bottom - r.top;
1873 }
1874
1875 GdkWindow*
1876 _gdk_windowing_window_get_pointer (GdkDisplay      *display,
1877                                    GdkWindow       *window,
1878                                    gint            *x,
1879                                    gint            *y,
1880                                    GdkModifierType *mask)
1881 {
1882   GdkWindow *return_val;
1883   POINT screen_point, point;
1884   HWND hwnd, hwndc;
1885   BYTE kbd[256];
1886
1887   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1888
1889   return_val = NULL;
1890   GetCursorPos (&screen_point);
1891   point = screen_point;
1892   ScreenToClient (GDK_WINDOW_HWND (window), &point);
1893
1894   *x = point.x;
1895   *y = point.y;
1896
1897   hwnd = WindowFromPoint (point);
1898   if (hwnd != NULL)
1899     {
1900       gboolean done = FALSE;
1901
1902       while (!done)
1903         {
1904           point = screen_point;
1905           ScreenToClient (hwnd, &point);
1906           hwndc = ChildWindowFromPoint (hwnd, point);
1907           if (hwndc == NULL)
1908             done = TRUE;
1909           else if (hwndc == hwnd)
1910             done = TRUE;
1911           else
1912             hwnd = hwndc;
1913         }
1914
1915       return_val = gdk_window_lookup ((GdkNativeWindow) hwnd);
1916     }
1917   else
1918     return_val = NULL;
1919
1920   GetKeyboardState (kbd);
1921   *mask = 0;
1922   if (kbd[VK_SHIFT] & 0x80)
1923     *mask |= GDK_SHIFT_MASK;
1924   if (kbd[VK_CAPITAL] & 0x80)
1925     *mask |= GDK_LOCK_MASK;
1926   if (kbd[VK_CONTROL] & 0x80)
1927     *mask |= GDK_CONTROL_MASK;
1928   if (kbd[VK_MENU] & 0x80)
1929     *mask |= GDK_MOD1_MASK;
1930   if (kbd[VK_LBUTTON] & 0x80)
1931     *mask |= GDK_BUTTON1_MASK;
1932   if (kbd[VK_MBUTTON] & 0x80)
1933     *mask |= GDK_BUTTON2_MASK;
1934   if (kbd[VK_RBUTTON] & 0x80)
1935     *mask |= GDK_BUTTON3_MASK;
1936
1937   return return_val;
1938 }
1939
1940 void
1941 _gdk_windowing_get_pointer (GdkDisplay       *display,
1942                             GdkScreen       **screen,
1943                             gint             *x,
1944                             gint             *y,
1945                             GdkModifierType  *mask)
1946 {
1947   GdkScreen *default_screen = gdk_display_get_default_screen (display);
1948   GdkWindow *root_window = gdk_screen_get_root_window (default_screen);
1949
1950   *screen = default_screen;
1951   _gdk_windowing_window_get_pointer (display, root_window, x, y, mask);
1952 }
1953
1954 GdkWindow*
1955 _gdk_windowing_window_at_pointer (GdkDisplay *display,
1956                                   gint       *win_x,
1957                                   gint       *win_y)
1958 {
1959   GdkWindow *window;
1960   POINT point, pointc;
1961   HWND hwnd, hwndc;
1962   RECT rect;
1963
1964   GetCursorPos (&pointc);
1965   point = pointc;
1966   hwnd = WindowFromPoint (point);
1967
1968   if (hwnd == NULL)
1969     {
1970       window = _gdk_parent_root;
1971       *win_x = pointc.x;
1972       *win_y = pointc.y;
1973       return window;
1974     }
1975
1976   ScreenToClient (hwnd, &point);
1977
1978   do {
1979     hwndc = ChildWindowFromPoint (hwnd, point);
1980     ClientToScreen (hwnd, &point);
1981     ScreenToClient (hwndc, &point);
1982   } while (hwndc != hwnd && (hwnd = hwndc, 1));
1983
1984   window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
1985
1986   if (window && (win_x || win_y))
1987     {
1988       GetClientRect (hwnd, &rect);
1989       *win_x = point.x - rect.left;
1990       *win_y = point.y - rect.top;
1991     }
1992
1993   GDK_NOTE (MISC, g_print ("gdk_window_at_pointer: +%ld+%ld %p%s\n",
1994                            point.x, point.y,
1995                            hwnd,
1996                            (window == NULL ? " NULL" : "")));
1997
1998   return window;
1999 }
2000
2001 GdkEventMask
2002 gdk_window_get_events (GdkWindow *window)
2003 {
2004   g_return_val_if_fail (window != NULL, 0);
2005   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
2006
2007   if (GDK_WINDOW_DESTROYED (window))
2008     return 0;
2009
2010   return GDK_WINDOW_OBJECT (window)->event_mask;
2011 }
2012
2013 void
2014 gdk_window_set_events (GdkWindow   *window,
2015                        GdkEventMask event_mask)
2016 {
2017   g_return_if_fail (window != NULL);
2018   g_return_if_fail (GDK_IS_WINDOW (window));
2019
2020   if (GDK_WINDOW_DESTROYED (window))
2021     return;
2022
2023   /* gdk_window_new() always sets the GDK_STRUCTURE_MASK, so better
2024    * set it here, too. Not that I know or remember why it is
2025    * necessary, will have to test some day.
2026    */
2027   GDK_WINDOW_OBJECT (window)->event_mask = GDK_STRUCTURE_MASK | event_mask;
2028 }
2029
2030 void
2031 gdk_window_shape_combine_mask (GdkWindow *window,
2032                                GdkBitmap *mask,
2033                                gint x, gint y)
2034 {
2035   g_return_if_fail (window != NULL);
2036   g_return_if_fail (GDK_IS_WINDOW (window));
2037
2038   if (!mask)
2039     {
2040       GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %p none\n",
2041                                GDK_WINDOW_HWND (window)));
2042       SetWindowRgn (GDK_WINDOW_HWND (window), NULL, TRUE);
2043     }
2044   else
2045     {
2046       HRGN hrgn;
2047       DWORD dwStyle;
2048       DWORD dwExStyle;
2049       RECT rect;
2050
2051       /* Convert mask bitmap to region */
2052       hrgn = _gdk_win32_bitmap_to_hrgn (mask);
2053
2054       GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %p %p\n",
2055                                GDK_WINDOW_HWND (window),
2056                                GDK_WINDOW_HWND (mask)));
2057
2058       /* SetWindowRgn wants window (not client) coordinates */
2059       dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
2060       dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
2061       GetClientRect (GDK_WINDOW_HWND (window), &rect);
2062       AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
2063       OffsetRgn (hrgn, -rect.left, -rect.top);
2064
2065       OffsetRgn (hrgn, x, y);
2066
2067       /* If this is a top-level window, add the title bar to the region */
2068       if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL)
2069         {
2070           HRGN tmp = CreateRectRgn (0, 0, rect.right - rect.left, -rect.top);
2071           CombineRgn (hrgn, hrgn, tmp, RGN_OR);
2072           DeleteObject (tmp);
2073         }
2074
2075       SetWindowRgn (GDK_WINDOW_HWND (window), hrgn, TRUE);
2076     }
2077 }
2078
2079 void
2080 gdk_window_set_override_redirect (GdkWindow *window,
2081                                   gboolean   override_redirect)
2082 {
2083   g_return_if_fail (window != NULL);
2084   g_return_if_fail (GDK_IS_WINDOW (window));
2085
2086   g_warning ("gdk_window_set_override_redirect not implemented");
2087 }
2088
2089 void
2090 gdk_window_set_icon_list (GdkWindow *window,
2091                           GList     *pixbufs)
2092 {
2093   g_return_if_fail (GDK_IS_WINDOW (window));
2094
2095   if (GDK_WINDOW_DESTROYED (window))
2096     return;
2097
2098   /* We could convert it to a hIcon and DrawIcon () it when getting
2099    * a WM_PAINT with IsIconic, but is it worth it ? Same probably
2100    * goes for gdk_window_set_icon (). Patches accepted :-)  --hb
2101    * Or do we only need to deliver the Icon on WM_GETICON ?
2102    */
2103 }
2104
2105 void
2106 gdk_window_set_icon (GdkWindow *window,
2107                      GdkWindow *icon_window,
2108                      GdkPixmap *pixmap,
2109                      GdkBitmap *mask)
2110 {
2111   g_return_if_fail (window != NULL);
2112   g_return_if_fail (GDK_IS_WINDOW (window));
2113
2114   if (GDK_WINDOW_DESTROYED (window))
2115     return;
2116
2117   /* Nothing to do, really. As we share window classes between windows
2118    * we can't have window-specific icons, sorry. Don't print any warning
2119    * either.
2120    */
2121 }
2122
2123 void
2124 gdk_window_set_icon_name (GdkWindow   *window,
2125                           const gchar *name)
2126 {
2127   g_return_if_fail (window != NULL);
2128   g_return_if_fail (GDK_IS_WINDOW (window));
2129
2130   if (GDK_WINDOW_DESTROYED (window))
2131     return;
2132
2133   if (!SetWindowText (GDK_WINDOW_HWND (window), name))
2134     WIN32_API_FAILED ("SetWindowText");
2135 }
2136
2137 void
2138 gdk_window_set_group (GdkWindow *window,
2139                       GdkWindow *leader)
2140 {
2141   g_return_if_fail (window != NULL);
2142   g_return_if_fail (GDK_IS_WINDOW (window));
2143   g_return_if_fail (leader != NULL);
2144   g_return_if_fail (GDK_IS_WINDOW (leader));
2145
2146   if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (leader))
2147     return;
2148
2149   g_warning ("gdk_window_set_group not implemented");
2150 }
2151
2152 void
2153 gdk_window_set_decorations (GdkWindow      *window,
2154                             GdkWMDecoration decorations)
2155 {
2156   LONG style;
2157
2158   g_return_if_fail (window != NULL);
2159   g_return_if_fail (GDK_IS_WINDOW (window));
2160
2161   GDK_NOTE (MISC, g_print ("gdk_window_set_decorations: %p %s%s%s%s%s%s%s\n",
2162                            GDK_WINDOW_HWND (window),
2163                            (decorations & GDK_DECOR_ALL ? "ALL " : ""),
2164                            (decorations & GDK_DECOR_BORDER ? "BORDER " : ""),
2165                            (decorations & GDK_DECOR_RESIZEH ? "RESIZEH " : ""),
2166                            (decorations & GDK_DECOR_TITLE ? "TITLE " : ""),
2167                            (decorations & GDK_DECOR_MENU ? "MENU " : ""),
2168                            (decorations & GDK_DECOR_MINIMIZE ? "MINIMIZE " : ""),
2169                            (decorations & GDK_DECOR_MAXIMIZE ? "MAXIMIZE " : "")));
2170
2171   style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
2172
2173   style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
2174             |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
2175
2176   if (decorations & GDK_DECOR_ALL)
2177     style |= (WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
2178   if (decorations & GDK_DECOR_BORDER)
2179     style |= (WS_BORDER);
2180   if (decorations & GDK_DECOR_RESIZEH)
2181     style |= (WS_THICKFRAME);
2182   if (decorations & GDK_DECOR_TITLE)
2183     style |= (WS_CAPTION);
2184   if (decorations & GDK_DECOR_MENU)
2185     style |= (WS_SYSMENU);
2186   if (decorations & GDK_DECOR_MINIMIZE)
2187     style |= (WS_MINIMIZEBOX);
2188   if (decorations & GDK_DECOR_MAXIMIZE)
2189     style |= (WS_MAXIMIZEBOX);
2190
2191   SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
2192   SetWindowPos (GDK_WINDOW_HWND (window), NULL, 0, 0, 0, 0,
2193                 SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE |
2194                 SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER);
2195 }
2196
2197 void
2198 gdk_window_set_functions (GdkWindow    *window,
2199                           GdkWMFunction functions)
2200 {
2201   LONG style;
2202
2203   g_return_if_fail (window != NULL);
2204   g_return_if_fail (GDK_IS_WINDOW (window));
2205
2206   GDK_NOTE (MISC, g_print ("gdk_window_set_functions: %p %s%s%s%s%s%s\n",
2207                            GDK_WINDOW_HWND (window),
2208                            (functions & GDK_FUNC_ALL ? "ALL " : ""),
2209                            (functions & GDK_FUNC_RESIZE ? "RESIZE " : ""),
2210                            (functions & GDK_FUNC_MOVE ? "MOVE " : ""),
2211                            (functions & GDK_FUNC_MINIMIZE ? "MINIMIZE " : ""),
2212                            (functions & GDK_FUNC_MAXIMIZE ? "MAXIMIZE " : ""),
2213                            (functions & GDK_FUNC_CLOSE ? "CLOSE " : "")));
2214
2215   style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
2216
2217   style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
2218             |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
2219             |WS_SYSMENU);
2220
2221   if (functions & GDK_FUNC_ALL)
2222     style |= (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
2223   if (functions & GDK_FUNC_RESIZE)
2224     style |= (WS_THICKFRAME);
2225   if (functions & GDK_FUNC_MOVE)
2226     style |= (WS_THICKFRAME);
2227   if (functions & GDK_FUNC_MINIMIZE)
2228     style |= (WS_MINIMIZEBOX);
2229   if (functions & GDK_FUNC_MAXIMIZE)
2230     style |= (WS_MAXIMIZEBOX);
2231
2232   SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
2233   SetWindowPos (GDK_WINDOW_HWND (window), NULL, 0, 0, 0, 0,
2234                 SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE |
2235                 SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER);
2236 }
2237
2238 static void
2239 QueryTree (HWND   hwnd,
2240            HWND **children,
2241            gint  *nchildren)
2242 {
2243   guint i, n;
2244   HWND child;
2245
2246   n = 0;
2247   do {
2248     if (n == 0)
2249       child = GetWindow (hwnd, GW_CHILD);
2250     else
2251       child = GetWindow (child, GW_HWNDNEXT);
2252     if (child != NULL)
2253       n++;
2254   } while (child != NULL);
2255
2256   if (n > 0)
2257     {
2258       *children = g_new (HWND, n);
2259       for (i = 0; i < n; i++)
2260         {
2261           if (i == 0)
2262             child = GetWindow (hwnd, GW_CHILD);
2263           else
2264             child = GetWindow (child, GW_HWNDNEXT);
2265           *children[i] = child;
2266         }
2267     }
2268 }
2269
2270 static void
2271 gdk_propagate_shapes (HANDLE   win,
2272                       gboolean merge)
2273 {
2274    RECT emptyRect;
2275    HRGN region, childRegion;
2276    HWND *list = NULL;
2277    gint i, num;
2278
2279    SetRectEmpty (&emptyRect);
2280    region = CreateRectRgnIndirect (&emptyRect);
2281    if (merge)
2282      GetWindowRgn (win, region);
2283
2284    QueryTree (win, &list, &num);
2285    if (list != NULL)
2286      {
2287        WINDOWPLACEMENT placement;
2288
2289        placement.length = sizeof (WINDOWPLACEMENT);
2290        /* go through all child windows and combine regions */
2291        for (i = 0; i < num; i++)
2292          {
2293            GetWindowPlacement (list[i], &placement);
2294            if (placement.showCmd == SW_SHOWNORMAL)
2295              {
2296                childRegion = CreateRectRgnIndirect (&emptyRect);
2297                GetWindowRgn (list[i], childRegion);
2298                CombineRgn (region, region, childRegion, RGN_OR);
2299                DeleteObject (childRegion);
2300              }
2301           }
2302        SetWindowRgn (win, region, TRUE);
2303        g_free (list);
2304      }
2305    else
2306      DeleteObject (region);
2307 }
2308
2309 void
2310 gdk_window_set_child_shapes (GdkWindow *window)
2311 {
2312   g_return_if_fail (window != NULL);
2313   g_return_if_fail (GDK_IS_WINDOW (window));
2314
2315   if (GDK_WINDOW_DESTROYED (window))
2316     return;
2317
2318   gdk_propagate_shapes (GDK_WINDOW_HWND (window), FALSE);
2319 }
2320
2321 void
2322 gdk_window_merge_child_shapes (GdkWindow *window)
2323 {
2324   g_return_if_fail (window != NULL);
2325   g_return_if_fail (GDK_IS_WINDOW (window));
2326
2327   if (GDK_WINDOW_DESTROYED (window))
2328     return;
2329
2330   gdk_propagate_shapes (GDK_WINDOW_HWND (window), TRUE);
2331 }
2332
2333 gboolean
2334 gdk_window_set_static_gravities (GdkWindow *window,
2335                                  gboolean   use_static)
2336 {
2337   GdkWindowObject *private = (GdkWindowObject *)window;
2338
2339   g_return_val_if_fail (window != NULL, FALSE);
2340   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2341
2342   if (!use_static == !private->guffaw_gravity)
2343     return TRUE;
2344
2345   if (use_static)
2346     return FALSE;
2347
2348   private->guffaw_gravity = use_static;
2349
2350   return TRUE;
2351 }
2352
2353 /*
2354  * Setting window states
2355  */
2356 void
2357 gdk_window_iconify (GdkWindow *window)
2358 {
2359   HWND old_active_window;
2360
2361   g_return_if_fail (window != NULL);
2362   g_return_if_fail (GDK_IS_WINDOW (window));
2363
2364   if (GDK_WINDOW_DESTROYED (window))
2365     return;
2366
2367   GDK_NOTE (MISC, g_print ("gdk_window_iconify: %p %s\n",
2368                            GDK_WINDOW_HWND (window),
2369                            _gdk_win32_window_state_to_string (((GdkWindowObject *) window)->state)));
2370
2371   if (GDK_WINDOW_IS_MAPPED (window))
2372     {
2373       old_active_window = GetActiveWindow ();
2374       ShowWindow (GDK_WINDOW_HWND (window), SW_MINIMIZE);
2375       if (old_active_window != GDK_WINDOW_HWND (window))
2376         SetActiveWindow (old_active_window);
2377     }
2378   else
2379     {
2380       gdk_synthesize_window_state (window,
2381                                    0,
2382                                    GDK_WINDOW_STATE_ICONIFIED);
2383     }
2384 }
2385
2386 void
2387 gdk_window_deiconify (GdkWindow *window)
2388 {
2389   g_return_if_fail (window != NULL);
2390   g_return_if_fail (GDK_IS_WINDOW (window));
2391
2392   if (GDK_WINDOW_DESTROYED (window))
2393     return;
2394
2395   GDK_NOTE (MISC, g_print ("gdk_window_deiconify: %p %s\n",
2396                            GDK_WINDOW_HWND (window),
2397                            _gdk_win32_window_state_to_string (((GdkWindowObject *) window)->state)));
2398
2399   if (GDK_WINDOW_IS_MAPPED (window))
2400     {
2401       show_window_internal (window, FALSE, TRUE);
2402     }
2403   else
2404     {
2405       gdk_synthesize_window_state (window,
2406                                    GDK_WINDOW_STATE_ICONIFIED,
2407                                    0);
2408     }
2409 }
2410
2411 void
2412 gdk_window_stick (GdkWindow *window)
2413 {
2414   g_return_if_fail (GDK_IS_WINDOW (window));
2415
2416   if (GDK_WINDOW_DESTROYED (window))
2417     return;
2418
2419   /* FIXME: Do something? */
2420 }
2421
2422 void
2423 gdk_window_unstick (GdkWindow *window)
2424 {
2425   g_return_if_fail (GDK_IS_WINDOW (window));
2426
2427   if (GDK_WINDOW_DESTROYED (window))
2428     return;
2429
2430   /* FIXME: Do something? */
2431 }
2432
2433 void
2434 gdk_window_maximize (GdkWindow *window)
2435 {
2436   g_return_if_fail (GDK_IS_WINDOW (window));
2437
2438   if (GDK_WINDOW_DESTROYED (window))
2439     return;
2440
2441   GDK_NOTE (MISC, g_print ("gdk_window_maximize: %p %s\n",
2442                            GDK_WINDOW_HWND (window),
2443                            _gdk_win32_window_state_to_string (((GdkWindowObject *) window)->state)));
2444
2445   if (GDK_WINDOW_IS_MAPPED (window))
2446     ShowWindow (GDK_WINDOW_HWND (window), SW_MAXIMIZE);
2447   else
2448     gdk_synthesize_window_state (window,
2449                                  0,
2450                                  GDK_WINDOW_STATE_MAXIMIZED);
2451 }
2452
2453 void
2454 gdk_window_unmaximize (GdkWindow *window)
2455 {
2456   g_return_if_fail (GDK_IS_WINDOW (window));
2457
2458   if (GDK_WINDOW_DESTROYED (window))
2459     return;
2460
2461   GDK_NOTE (MISC, g_print ("gdk_window_unmaximize: %p %s\n",
2462                            GDK_WINDOW_HWND (window),
2463                            _gdk_win32_window_state_to_string (((GdkWindowObject *) window)->state)));
2464
2465   if (GDK_WINDOW_IS_MAPPED (window))
2466     ShowWindow (GDK_WINDOW_HWND (window), SW_RESTORE);
2467   else
2468     gdk_synthesize_window_state (window,
2469                                  GDK_WINDOW_STATE_MAXIMIZED,
2470                                  0);
2471 }
2472
2473 void
2474 gdk_window_fullscreen (GdkWindow *window)
2475 {
2476   g_return_if_fail (GDK_IS_WINDOW (window));
2477
2478   g_warning ("gdk_window_fullscreen() not implemented.\n");
2479 }
2480
2481 void
2482 gdk_window_unfullscreen (GdkWindow *window)
2483 {
2484   g_return_if_fail (GDK_IS_WINDOW (window));
2485 }
2486
2487 void
2488 gdk_window_focus (GdkWindow *window,
2489                   guint32    timestamp)
2490 {
2491   g_return_if_fail (GDK_IS_WINDOW (window));
2492
2493   if (GDK_WINDOW_DESTROYED (window))
2494     return;
2495
2496   GDK_NOTE (MISC, g_print ("gdk_window_focus: %p %s\n",
2497                            GDK_WINDOW_HWND (window),
2498                            _gdk_win32_window_state_to_string (((GdkWindowObject *) window)->state)));
2499
2500   ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNORMAL);
2501   SetFocus (GDK_WINDOW_HWND (window));
2502 }
2503
2504 void
2505 gdk_window_set_modal_hint (GdkWindow *window,
2506                            gboolean   modal)
2507 {
2508   GdkWindowObject *private;
2509
2510   g_return_if_fail (window != NULL);
2511   g_return_if_fail (GDK_IS_WINDOW (window));
2512
2513   if (GDK_WINDOW_DESTROYED (window))
2514     return;
2515
2516   private = (GdkWindowObject*) window;
2517
2518   private->modal_hint = modal;
2519
2520   if (GDK_WINDOW_IS_MAPPED (window))
2521     if (!SetWindowPos (GDK_WINDOW_HWND (window), HWND_TOPMOST,
2522                        0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE))
2523       WIN32_API_FAILED ("SetWindowPos");
2524 }
2525
2526 void
2527 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
2528                                   gboolean   skips_taskbar)
2529 {
2530   g_return_if_fail (GDK_IS_WINDOW (window));
2531 }
2532
2533 void
2534 gdk_window_set_skip_pager_hint (GdkWindow *window,
2535                                 gboolean   skips_pager)
2536 {
2537   g_return_if_fail (GDK_IS_WINDOW (window));
2538 }
2539
2540 void
2541 gdk_window_set_type_hint (GdkWindow        *window,
2542                           GdkWindowTypeHint hint)
2543 {
2544   g_return_if_fail (window != NULL);
2545   g_return_if_fail (GDK_IS_WINDOW (window));
2546
2547   if (GDK_WINDOW_DESTROYED (window))
2548     return;
2549
2550   switch (hint)
2551     {
2552     case GDK_WINDOW_TYPE_HINT_DIALOG:
2553       break;
2554     case GDK_WINDOW_TYPE_HINT_MENU:
2555       break;
2556     case GDK_WINDOW_TYPE_HINT_TOOLBAR:
2557       break;
2558     default:
2559       g_warning ("Unknown hint %d passed to gdk_window_set_type_hint", hint);
2560       /* Fall thru */
2561     case GDK_WINDOW_TYPE_HINT_NORMAL:
2562       break;
2563     }
2564   /*
2565    * XXX ???
2566    */
2567   GDK_NOTE (MISC, g_print ("gdk_window_set_type_hint: %p\n",
2568                            GDK_WINDOW_HWND (window)));
2569 }
2570
2571 void
2572 gdk_window_shape_combine_region (GdkWindow *window,
2573                                  GdkRegion *shape_region,
2574                                  gint       offset_x,
2575                                  gint       offset_y)
2576 {
2577   g_return_if_fail (GDK_IS_WINDOW (window));
2578
2579   if (GDK_WINDOW_DESTROYED (window))
2580     return;
2581
2582   /* XXX: even on X implemented conditional ... */
2583 }
2584
2585 void
2586 gdk_window_begin_resize_drag (GdkWindow     *window,
2587                               GdkWindowEdge  edge,
2588                               gint           button,
2589                               gint           root_x,
2590                               gint           root_y,
2591                               guint32        timestamp)
2592 {
2593   g_return_if_fail (GDK_IS_WINDOW (window));
2594
2595   if (GDK_WINDOW_DESTROYED (window))
2596     return;
2597
2598   /* XXX: isn't all this default on win32 ... */
2599 }
2600
2601 void
2602 gdk_window_begin_move_drag (GdkWindow *window,
2603                             gint       button,
2604                             gint       root_x,
2605                             gint       root_y,
2606                             guint32    timestamp)
2607 {
2608   g_return_if_fail (GDK_IS_WINDOW (window));
2609
2610   if (GDK_WINDOW_DESTROYED (window))
2611     return;
2612
2613   /* XXX: isn't all this default on win32 ... */
2614 }
2615
2616 GdkWindow *
2617 gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
2618 {
2619   g_return_val_if_fail (display == gdk_display_get_default(), NULL);
2620
2621   return gdk_window_lookup (anid);
2622 }