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