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
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.
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.
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.
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/.
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"
38 static gboolean gdk_window_gravity_works (void);
39 static void gdk_window_set_static_win_gravity (GdkWindow *window,
42 static GdkColormap* gdk_window_impl_win32_get_colormap (GdkDrawable *drawable);
43 static void gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
45 static void gdk_window_impl_win32_get_size (GdkDrawable *drawable,
48 static GdkRegion* gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable);
49 static void gdk_window_impl_win32_init (GdkWindowImplWin32 *window);
50 static void gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass);
51 static void gdk_window_impl_win32_finalize (GObject *object);
53 static gpointer parent_class = NULL;
55 GdkWindow *_gdk_parent_root = NULL;
58 _gdk_window_impl_win32_get_type (void)
60 static GType object_type = 0;
64 static const GTypeInfo object_info =
66 sizeof (GdkWindowImplWin32Class),
68 (GBaseFinalizeFunc) NULL,
69 (GClassInitFunc) gdk_window_impl_win32_class_init,
70 NULL, /* class_finalize */
71 NULL, /* class_data */
72 sizeof (GdkWindowImplWin32),
74 (GInstanceInitFunc) gdk_window_impl_win32_init,
77 object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_WIN32,
86 _gdk_window_impl_get_type (void)
88 return _gdk_window_impl_win32_get_type ();
92 gdk_window_impl_win32_init (GdkWindowImplWin32 *impl)
99 impl->extension_events_selected = FALSE;
103 gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass)
105 GObjectClass *object_class = G_OBJECT_CLASS (klass);
106 GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
108 parent_class = g_type_class_peek_parent (klass);
110 object_class->finalize = gdk_window_impl_win32_finalize;
112 drawable_class->set_colormap = gdk_window_impl_win32_set_colormap;
113 drawable_class->get_colormap = gdk_window_impl_win32_get_colormap;
114 drawable_class->get_size = gdk_window_impl_win32_get_size;
116 /* Visible and clip regions are the same */
117 drawable_class->get_clip_region = gdk_window_impl_win32_get_visible_region;
118 drawable_class->get_visible_region = gdk_window_impl_win32_get_visible_region;
122 gdk_window_impl_win32_finalize (GObject *object)
124 GdkWindowObject *wrapper;
125 GdkDrawableImplWin32 *draw_impl;
126 GdkWindowImplWin32 *window_impl;
128 g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (object));
130 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (object);
131 window_impl = GDK_WINDOW_IMPL_WIN32 (object);
133 wrapper = (GdkWindowObject*) draw_impl->wrapper;
135 if (!GDK_WINDOW_DESTROYED (wrapper))
137 gdk_win32_handle_table_remove (draw_impl->handle);
140 if (window_impl->hcursor != NULL)
142 if (GetCursor () == window_impl->hcursor)
144 if (!DestroyCursor (window_impl->hcursor))
145 WIN32_GDI_FAILED("DestroyCursor");
146 window_impl->hcursor = NULL;
149 G_OBJECT_CLASS (parent_class)->finalize (object);
153 gdk_window_impl_win32_get_colormap (GdkDrawable *drawable)
155 GdkDrawableImplWin32 *drawable_impl;
157 g_return_val_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable), NULL);
159 drawable_impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
161 if (!((GdkWindowObject *) drawable_impl->wrapper)->input_only &&
162 drawable_impl->colormap == NULL)
164 drawable_impl->colormap = gdk_colormap_get_system ();
165 gdk_colormap_ref (drawable_impl->colormap);
168 return drawable_impl->colormap;
172 gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
175 GdkWindowImplWin32 *impl;
176 GdkDrawableImplWin32 *draw_impl;
178 g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable));
180 impl = GDK_WINDOW_IMPL_WIN32 (drawable);
181 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
184 GDK_DRAWABLE_CLASS (parent_class)->set_colormap (drawable, cmap);
189 g_print("gdk_window_impl_win32_set_colormap: XXX\n");
194 gdk_window_impl_win32_get_size (GdkDrawable *drawable,
198 g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable));
201 *width = GDK_WINDOW_IMPL_WIN32 (drawable)->width;
203 *height = GDK_WINDOW_IMPL_WIN32 (drawable)->height;
207 gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable)
209 GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (drawable);
210 GdkRectangle result_rect;
214 result_rect.width = impl->width;
215 result_rect.height = impl->height;
217 gdk_rectangle_intersect (&result_rect, &impl->position_info.clip_rect, &result_rect);
219 return gdk_region_rectangle (&result_rect);
223 _gdk_windowing_window_init (void)
225 GdkWindowObject *private;
226 GdkWindowImplWin32 *impl;
227 GdkDrawableImplWin32 *draw_impl;
232 g_assert (_gdk_parent_root == NULL);
234 SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);
235 width = rect.right - rect.left;
236 height = rect.bottom - rect.top;
238 _gdk_parent_root = g_object_new (GDK_TYPE_WINDOW, NULL);
239 private = (GdkWindowObject *)_gdk_parent_root;
240 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
241 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
243 draw_impl->handle = gdk_root_window;
244 draw_impl->wrapper = GDK_DRAWABLE (private);
245 draw_impl->colormap = gdk_colormap_get_system ();
246 gdk_colormap_ref (draw_impl->colormap);
248 private->window_type = GDK_WINDOW_ROOT;
249 private->depth = gdk_visual_get_system ()->depth;
251 impl->height = height;
253 gdk_win32_handle_table_insert (&gdk_root_window, _gdk_parent_root);
256 /* The Win API function AdjustWindowRect may return negative values
257 * resulting in obscured title bars. This helper function is coreccting it.
260 SafeAdjustWindowRectEx (RECT* lpRect,
265 if (!AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle))
267 WIN32_API_FAILED ("AdjustWindowRectEx");
270 if (lpRect->left < 0)
272 lpRect->right -= lpRect->left;
277 lpRect->bottom -= lpRect->top;
284 * is a wrapper function for RegisterWindowClassEx.
285 * It creates at least one unique class for every
286 * GdkWindowType. If support for single window-specific icons
287 * is ever needed (e.g Dialog specific), every such window should
291 RegisterGdkClass (GdkWindowType wtype)
293 static ATOM klassTOPLEVEL = 0;
294 static ATOM klassDIALOG = 0;
295 static ATOM klassCHILD = 0;
296 static ATOM klassTEMP = 0;
297 static HICON hAppIcon = NULL;
298 static WNDCLASSEX wcl;
301 wcl.cbSize = sizeof (WNDCLASSEX);
302 wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
303 * on WM_SIZE and WM_MOVE. Flicker, Performance!
305 wcl.lpfnWndProc = _gdk_win32_window_procedure;
308 wcl.hInstance = gdk_app_hmodule;
310 /* initialize once! */
313 gchar sLoc [MAX_PATH+1];
315 if (0 != GetModuleFileName (gdk_app_hmodule, sLoc, MAX_PATH))
317 hAppIcon = ExtractIcon (gdk_app_hmodule, sLoc, 0);
320 if (0 != GetModuleFileName (gdk_dll_hinstance, sLoc, MAX_PATH))
321 hAppIcon = ExtractIcon (gdk_dll_hinstance, sLoc, 0);
325 hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
328 wcl.lpszMenuName = NULL;
331 /* initialize once per class */
333 * HB: Setting the background brush leads to flicker, because we
334 * don't get asked how to clear the background. This is not what
335 * we want, at least not for input_only windows ...
337 #define ONCE_PER_CLASS() \
338 wcl.hIcon = CopyIcon (hAppIcon); \
339 wcl.hIconSm = CopyIcon (hAppIcon); \
340 wcl.hbrBackground = NULL; \
341 wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
345 case GDK_WINDOW_TOPLEVEL:
346 if (0 == klassTOPLEVEL)
348 wcl.lpszClassName = "gdkWindowToplevel";
351 klassTOPLEVEL = RegisterClassEx (&wcl);
353 klass = klassTOPLEVEL;
356 case GDK_WINDOW_CHILD:
359 wcl.lpszClassName = "gdkWindowChild";
361 wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
363 klassCHILD = RegisterClassEx (&wcl);
368 case GDK_WINDOW_DIALOG:
369 if (0 == klassDIALOG)
371 wcl.lpszClassName = "gdkWindowDialog";
372 wcl.style |= CS_SAVEBITS;
374 klassDIALOG = RegisterClassEx (&wcl);
379 case GDK_WINDOW_TEMP:
382 wcl.lpszClassName = "gdkWindowTemp";
383 wcl.style |= CS_SAVEBITS;
385 klassTEMP = RegisterClassEx (&wcl);
391 g_assert_not_reached ();
397 WIN32_API_FAILED ("RegisterClassEx");
398 g_error ("That is a fatal error");
404 gdk_window_new (GdkWindow *parent,
405 GdkWindowAttr *attributes,
406 gint attributes_mask)
410 DWORD dwStyle, dwExStyle;
413 GdkWindowObject *private;
414 GdkWindowImplWin32 *impl;
415 GdkDrawableImplWin32 *draw_impl;
422 g_return_val_if_fail (attributes != NULL, NULL);
425 parent = _gdk_parent_root;
427 g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
430 g_print ("gdk_window_new: %s\n",
431 (attributes->window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
432 (attributes->window_type == GDK_WINDOW_CHILD ? "CHILD" :
433 (attributes->window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
434 (attributes->window_type == GDK_WINDOW_TEMP ? "TEMP" :
437 if (GDK_WINDOW_DESTROYED (parent))
440 hparent = GDK_WINDOW_HWND (parent);
442 window = g_object_new (GDK_TYPE_WINDOW, NULL);
443 private = (GdkWindowObject *)window;
444 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
445 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
446 draw_impl->wrapper = GDK_DRAWABLE (window);
448 /* Windows with a foreign parent are treated as if they are children
449 * of the root window, except for actual creation.
451 if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
452 parent = _gdk_parent_root;
454 private->parent = (GdkWindowObject *)parent;
456 if (attributes_mask & GDK_WA_X)
461 if (attributes_mask & GDK_WA_Y)
463 else if (attributes_mask & GDK_WA_X)
464 y = 100; /* ??? We must put it somewhere... */
466 y = 0; /* x is CW_USEDEFAULT, y doesn't matter then */
470 impl->width = (attributes->width > 1) ? (attributes->width) : (1);
471 impl->height = (attributes->height > 1) ? (attributes->height) : (1);
472 impl->extension_events_selected = FALSE;
473 private->window_type = attributes->window_type;
475 _gdk_window_init_position (GDK_WINDOW (private));
476 if (impl->position_info.big)
477 private->guffaw_gravity = TRUE;
479 if (attributes_mask & GDK_WA_VISUAL)
480 visual = attributes->visual;
482 visual = gdk_visual_get_system ();
484 if (attributes_mask & GDK_WA_TITLE)
485 title = attributes->title;
487 title = g_get_prgname ();
488 if (!title || !*title)
489 title = "GDK client window";
491 private->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
493 if (private->parent && private->parent->guffaw_gravity)
498 if (attributes->wclass == GDK_INPUT_OUTPUT)
502 private->input_only = FALSE;
503 private->depth = visual->depth;
505 if (attributes_mask & GDK_WA_COLORMAP)
507 draw_impl->colormap = attributes->colormap;
508 gdk_colormap_ref (attributes->colormap);
512 draw_impl->colormap = gdk_colormap_get_system ();
517 dwExStyle = WS_EX_TRANSPARENT;
519 private->input_only = TRUE;
520 draw_impl->colormap = gdk_colormap_get_system ();
521 gdk_colormap_ref (draw_impl->colormap);
522 GDK_NOTE (MISC, g_print ("...GDK_INPUT_ONLY, system colormap\n"));
526 private->parent->children = g_list_prepend (private->parent->children, window);
528 switch (private->window_type)
530 case GDK_WINDOW_TOPLEVEL:
531 dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
532 hparent = gdk_root_window;
535 case GDK_WINDOW_CHILD:
536 dwStyle = WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
539 case GDK_WINDOW_DIALOG:
540 dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
542 dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
544 hparent = gdk_root_window;
547 case GDK_WINDOW_TEMP:
548 dwStyle = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
549 /* a temp window is not necessarily a top level window */
550 dwStyle |= (_gdk_parent_root == parent ? WS_POPUP : WS_CHILDWINDOW);
551 dwExStyle |= WS_EX_TOOLWINDOW;
554 case GDK_WINDOW_ROOT:
555 g_error ("cannot make windows of type GDK_WINDOW_ROOT");
559 klass = RegisterGdkClass (private->window_type);
561 if (private->window_type != GDK_WINDOW_CHILD)
563 if (x == CW_USEDEFAULT)
574 rect.right = rect.left + impl->width;
575 rect.bottom = rect.top + impl->height;
577 SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
579 if (x != CW_USEDEFAULT)
584 width = rect.right - rect.left;
585 height = rect.bottom - rect.top;
590 height = impl->height;
593 mbtitle = g_locale_from_utf8 (title, -1, NULL, NULL, NULL);
595 #ifdef WITHOUT_WM_CREATE
596 draw_impl->handle = CreateWindowEx (dwExStyle,
597 MAKEINTRESOURCE(klass),
600 impl->position_info.x, impl->position_info.y,
601 impl->position_info.width, impl->position_info.height,
609 CreateWindowEx (dwExStyle,
610 MAKEINTRESOURCE(klass),
613 impl->position_info.x, impl->position_info.y,
614 impl->position_info.width, impl->position_info.height,
619 if (GDK_WINDOW_HWND (window) != hwndNew)
621 g_warning("gdk_window_new: gdk_event_translate::WM_CREATE (%p, %p) HWND mismatch.",
622 GDK_WINDOW_HWND (window),
625 /* HB: IHMO due to a race condition the handle was increased by
626 * one, which causes much trouble. Because I can't find the
627 * real bug, try to workaround it ...
628 * To reproduce: compile with MSVC 5, DEBUG=1
631 gdk_win32_handle_table_remove (GDK_WINDOW_HWND (window));
632 GDK_WINDOW_HWND (window) = hwndNew;
633 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
635 /* the old behaviour, but with warning */
636 GDK_WINDOW_HWND (window) = hwndNew;
641 gdk_drawable_ref (window);
642 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
646 g_print ("... \"%s\" %dx%d@+%d+%d %p = %p\n",
648 width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
650 GDK_WINDOW_HWND (window)));
654 if (draw_impl->handle == NULL)
656 WIN32_API_FAILED ("CreateWindowEx");
657 g_object_unref ((GObject *) window);
661 #ifdef WITHOUT_WM_CREATE
662 gdk_drawable_ref (window);
663 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
666 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
667 (attributes->cursor) :
674 gdk_window_foreign_new_for_display (GdkDisplay *display,
675 GdkNativeWindow anid)
678 GdkWindowObject *private;
679 GdkWindowImplWin32 *impl;
680 GdkDrawableImplWin32 *draw_impl;
686 g_return_val_if_fail (display == gdk_display_get_default (), NULL);
688 window = g_object_new (GDK_TYPE_WINDOW, NULL);
689 private = (GdkWindowObject *)window;
690 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
691 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
692 draw_impl->wrapper = GDK_DRAWABLE (window);
693 parent = GetParent ((HWND)anid);
695 private->parent = gdk_win32_handle_table_lookup ((GdkNativeWindow) parent);
696 if (!private->parent || GDK_WINDOW_TYPE (private->parent) == GDK_WINDOW_FOREIGN)
697 private->parent = (GdkWindowObject *)_gdk_parent_root;
699 private->parent->children = g_list_prepend (private->parent->children, window);
701 draw_impl->handle = (HWND) anid;
702 GetClientRect ((HWND) anid, &rect);
704 point.y = rect.right;
705 ClientToScreen ((HWND) anid, &point);
706 if (parent != gdk_root_window)
707 ScreenToClient (parent, &point);
708 private->x = point.x;
709 private->y = point.y;
710 impl->width = rect.right - rect.left;
711 impl->height = rect.bottom - rect.top;
712 private->window_type = GDK_WINDOW_FOREIGN;
713 private->destroyed = FALSE;
714 private->event_mask = GDK_ALL_EVENTS_MASK; /* XXX */
715 if (IsWindowVisible ((HWND) anid))
716 private->state &= (~GDK_WINDOW_STATE_WITHDRAWN);
718 private->state |= GDK_WINDOW_STATE_WITHDRAWN;
719 private->depth = gdk_visual_get_system ()->depth;
721 gdk_drawable_ref (window);
722 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
728 gdk_window_lookup (GdkNativeWindow hwnd)
730 return (GdkWindow*) gdk_win32_handle_table_lookup (hwnd);
734 _gdk_windowing_window_destroy (GdkWindow *window,
736 gboolean foreign_destroy)
738 GdkWindowObject *private = (GdkWindowObject *)window;
740 g_return_if_fail (GDK_IS_WINDOW (window));
742 GDK_NOTE (MISC, g_print ("_gdk_windowing_window_destroy %p\n",
743 GDK_WINDOW_HWND (window)));
745 if (private->extension_events != 0)
746 _gdk_input_window_destroy (window);
748 if (private->window_type == GDK_WINDOW_FOREIGN)
750 if (!foreign_destroy && (private->parent != NULL))
752 /* It's somebody else's window, but in our hierarchy,
753 * so reparent it to the root window, and then call
754 * DestroyWindow() on it.
756 gdk_window_hide (window);
757 gdk_window_reparent (window, NULL, 0, 0);
759 /* Is this too drastic? Many (most?) applications
760 * quit if any window receives WM_QUIT I think.
761 * OTOH, I don't think foreign windows are much
762 * used, so the question is maybe academic.
764 PostMessage (GDK_WINDOW_HWND (window), WM_QUIT, 0, 0);
767 else if (!recursing && !foreign_destroy)
769 private->destroyed = TRUE;
770 DestroyWindow (GDK_WINDOW_HWND (window));
774 /* This function is called when the window really gone.
777 gdk_window_destroy_notify (GdkWindow *window)
779 g_return_if_fail (window != NULL);
780 g_return_if_fail (GDK_IS_WINDOW (window));
783 g_print ("gdk_window_destroy_notify: %p %s\n",
784 GDK_WINDOW_HWND (window),
785 (GDK_WINDOW_DESTROYED (window) ? "(destroyed)" : "")));
787 if (!GDK_WINDOW_DESTROYED (window))
789 if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
790 g_warning ("window %p unexpectedly destroyed",
791 GDK_WINDOW_HWND (window));
793 _gdk_window_destroy (window, TRUE);
796 gdk_win32_handle_table_remove (GDK_WINDOW_HWND (window));
797 gdk_drawable_unref (window);
801 show_window_internal (GdkWindow *window,
804 GdkWindowObject *private;
806 private = GDK_WINDOW_OBJECT (window);
808 if (!private->destroyed)
810 GDK_NOTE (MISC, g_print ("gdk_window_show: %p\n",
811 GDK_WINDOW_HWND (window)));
813 private->state &= (~GDK_WINDOW_STATE_WITHDRAWN);
814 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP)
816 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNOACTIVATE);
817 SetWindowPos (GDK_WINDOW_HWND (window), HWND_TOPMOST, 0, 0, 0, 0,
818 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
820 /* Don't put on toolbar */
821 ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
826 if (GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE) & WS_EX_TRANSPARENT)
828 SetWindowPos(GDK_WINDOW_HWND (window), HWND_TOP, 0, 0, 0, 0,
829 SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOMOVE | SWP_NOSIZE);
833 GdkWindow *parent = GDK_WINDOW (private->parent);
835 /* Todo: GDK_WINDOW_STATE_STICKY */
836 if (private->state & GDK_WINDOW_STATE_ICONIFIED)
837 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWMINIMIZED);
838 else if (private->state & GDK_WINDOW_STATE_MAXIMIZED)
839 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWMAXIMIZED);
842 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNORMAL);
843 ShowWindow (GDK_WINDOW_HWND (window), SW_RESTORE);
845 if (parent == _gdk_parent_root)
846 SetForegroundWindow (GDK_WINDOW_HWND (window));
848 BringWindowToTop (GDK_WINDOW_HWND (window));
850 ShowOwnedPopups (GDK_WINDOW_HWND (window), TRUE);
858 gdk_window_show_unraised (GdkWindow *window)
860 g_return_if_fail (GDK_IS_WINDOW (window));
862 show_window_internal (window, FALSE);
866 gdk_window_show (GdkWindow *window)
868 g_return_if_fail (GDK_IS_WINDOW (window));
870 show_window_internal (window, TRUE);
874 gdk_window_hide (GdkWindow *window)
876 GdkWindowObject *private;
878 g_return_if_fail (window != NULL);
880 private = (GdkWindowObject*) window;
881 if (!private->destroyed)
883 GDK_NOTE (MISC, g_print ("gdk_window_hide: %p\n",
884 GDK_WINDOW_HWND (window)));
886 private->state |= GDK_WINDOW_STATE_WITHDRAWN;
888 _gdk_window_clear_update_area (window);
890 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL)
891 ShowOwnedPopups (GDK_WINDOW_HWND (window), FALSE);
893 if (GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE) & WS_EX_TRANSPARENT)
895 SetWindowPos(GDK_WINDOW_HWND (window), HWND_BOTTOM, 0, 0, 0, 0,
896 SWP_HIDEWINDOW | SWP_NOREDRAW | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE);
900 ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
906 gdk_window_withdraw (GdkWindow *window)
908 GdkWindowObject *private;
910 g_return_if_fail (window != NULL);
912 private = (GdkWindowObject*) window;
913 if (!private->destroyed)
915 GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %p\n",
916 GDK_WINDOW_HWND (window)));
918 gdk_window_hide (window); /* ??? */
923 gdk_window_move (GdkWindow *window,
927 GdkWindowObject *private = (GdkWindowObject *)window;
928 GdkWindowImplWin32 *impl;
930 g_return_if_fail (window != NULL);
931 g_return_if_fail (GDK_IS_WINDOW (window));
933 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
935 if (!GDK_WINDOW_DESTROYED (window))
937 if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
938 _gdk_window_move_resize_child (window, x, y,
939 impl->width, impl->height);
942 if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL,
943 x, y, impl->width, impl->height,
944 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER))
945 WIN32_API_FAILED ("SetWindowPos");
951 gdk_window_resize (GdkWindow *window,
955 GdkWindowObject *private = (GdkWindowObject*) window;
956 GdkWindowImplWin32 *impl;
959 g_return_if_fail (window != NULL);
960 g_return_if_fail (GDK_IS_WINDOW (window));
967 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
969 if (!GDK_WINDOW_DESTROYED (window))
971 if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
972 _gdk_window_move_resize_child (window, private->x, private->y,
983 ClientToScreen (GDK_WINDOW_HWND (window), &pt);
986 rect.right = pt.x + width;
987 rect.bottom = pt.y + height;
989 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
990 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
991 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
992 WIN32_API_FAILED ("AdjustWindowRectEx");
996 width = rect.right - rect.left;
997 height = rect.bottom - rect.top;
998 if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL,
1000 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER))
1001 WIN32_API_FAILED ("SetWindowPos");
1003 private->resize_count += 1;
1008 gdk_window_move_resize (GdkWindow *window,
1014 GdkWindowObject *private = (GdkWindowObject*) window;
1015 GdkWindowImplWin32 *impl;
1017 g_return_if_fail (window != NULL);
1018 g_return_if_fail (GDK_IS_WINDOW (window));
1025 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
1027 if (!private->destroyed)
1033 GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %p %dx%d@+%d+%d\n",
1034 GDK_WINDOW_HWND (window),
1035 width, height, x, y));
1037 if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
1038 _gdk_window_move_resize_child (window, x, y, width, height);
1043 rect.right = x + width;
1044 rect.bottom = y + height;
1046 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1047 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1048 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
1049 WIN32_API_FAILED ("AdjustWindowRectEx");
1051 GDK_NOTE (MISC, g_print ("...SetWindowPos(%p,%ldx%ld@+%ld+%ld)\n",
1052 GDK_WINDOW_HWND (window),
1053 rect.right - rect.left, rect.bottom - rect.top,
1054 rect.left, rect.top));
1055 if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL,
1056 rect.left, rect.top,
1057 rect.right - rect.left, rect.bottom - rect.top,
1058 SWP_NOACTIVATE | SWP_NOZORDER))
1059 WIN32_API_FAILED ("SetWindowPos");
1065 gdk_window_reparent (GdkWindow *window,
1066 GdkWindow *new_parent,
1070 GdkWindowObject *window_private;
1071 GdkWindowObject *parent_private;
1072 GdkWindowObject *old_parent_private;
1073 GdkWindowImplWin32 *impl;
1075 g_return_if_fail (window != NULL);
1076 g_return_if_fail (GDK_IS_WINDOW (window));
1077 g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
1078 g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
1081 new_parent = _gdk_parent_root;
1083 window_private = (GdkWindowObject*) window;
1084 old_parent_private = (GdkWindowObject *) window_private->parent;
1085 parent_private = (GdkWindowObject*) new_parent;
1086 impl = GDK_WINDOW_IMPL_WIN32 (window_private->impl);
1088 if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (new_parent))
1090 GDK_NOTE (MISC, g_print ("gdk_window_reparent: %p %p\n",
1091 GDK_WINDOW_HWND (window),
1092 GDK_WINDOW_HWND (new_parent)));
1093 if (!SetParent (GDK_WINDOW_HWND (window),
1094 GDK_WINDOW_HWND (new_parent)))
1095 WIN32_API_FAILED ("SetParent");
1097 if (!MoveWindow (GDK_WINDOW_HWND (window),
1098 x, y, impl->width, impl->height, TRUE))
1099 WIN32_API_FAILED ("MoveWindow");
1102 /* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
1105 if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
1106 new_parent = _gdk_parent_root;
1108 window_private->parent = (GdkWindowObject *)new_parent;
1110 if (old_parent_private)
1111 old_parent_private->children =
1112 g_list_remove (old_parent_private->children, window);
1114 if ((old_parent_private &&
1115 (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
1116 (!old_parent_private && parent_private->guffaw_gravity))
1117 gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
1119 parent_private->children = g_list_prepend (parent_private->children, window);
1120 _gdk_window_init_position (GDK_WINDOW (window_private));
1124 _gdk_windowing_window_clear_area (GdkWindow *window,
1130 GdkWindowImplWin32 *impl;
1132 g_return_if_fail (window != NULL);
1133 g_return_if_fail (GDK_IS_WINDOW (window));
1135 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1137 if (!GDK_WINDOW_DESTROYED (window))
1142 width = impl->width - x;
1144 height = impl->height - y;
1145 GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area: "
1146 "%p %dx%d@+%d+%d\n",
1147 GDK_WINDOW_HWND (window),
1148 width, height, x, y));
1149 hdc = GetDC (GDK_WINDOW_HWND (window));
1150 IntersectClipRect (hdc, x, y, x + width + 1, y + height + 1);
1151 SendMessage (GDK_WINDOW_HWND (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
1152 if (!ReleaseDC (GDK_WINDOW_HWND (window), hdc))
1153 WIN32_GDI_FAILED ("ReleaseDC");
1158 _gdk_windowing_window_clear_area_e (GdkWindow *window,
1164 g_return_if_fail (window != NULL);
1165 g_return_if_fail (GDK_IS_WINDOW (window));
1167 if (!GDK_WINDOW_DESTROYED (window))
1171 GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area_e: "
1172 "%p %dx%d@+%d+%d\n",
1173 GDK_WINDOW_HWND (window),
1174 width, height, x, y));
1177 rect.right = x + width + 1;
1179 rect.bottom = y + height + 1;
1180 if (!InvalidateRect (GDK_WINDOW_HWND (window), &rect, TRUE))
1181 WIN32_GDI_FAILED ("InvalidateRect");
1182 UpdateWindow (GDK_WINDOW_HWND (window));
1187 gdk_window_raise (GdkWindow *window)
1189 g_return_if_fail (window != NULL);
1190 g_return_if_fail (GDK_IS_WINDOW (window));
1192 if (!GDK_WINDOW_DESTROYED (window))
1194 GDK_NOTE (MISC, g_print ("gdk_window_raise: %p\n",
1195 GDK_WINDOW_HWND (window)));
1197 if (!BringWindowToTop (GDK_WINDOW_HWND (window)))
1198 WIN32_API_FAILED ("BringWindowToTop");
1203 gdk_window_lower (GdkWindow *window)
1205 g_return_if_fail (window != NULL);
1206 g_return_if_fail (GDK_IS_WINDOW (window));
1208 if (!GDK_WINDOW_DESTROYED (window))
1210 GDK_NOTE (MISC, g_print ("gdk_window_lower: %p\n",
1211 GDK_WINDOW_HWND (window)));
1213 if (!SetWindowPos (GDK_WINDOW_HWND (window), HWND_BOTTOM, 0, 0, 0, 0,
1214 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
1215 WIN32_API_FAILED ("SetWindowPos");
1220 gdk_window_set_hints (GdkWindow *window,
1229 GdkWindowImplWin32 *impl;
1230 WINDOWPLACEMENT size_hints;
1236 g_return_if_fail (window != NULL);
1237 g_return_if_fail (GDK_IS_WINDOW (window));
1239 if (GDK_WINDOW_DESTROYED (window))
1242 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1244 GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %p %dx%d..%dx%d @+%d+%d\n",
1245 GDK_WINDOW_HWND (window),
1246 min_width, min_height, max_width, max_height,
1249 impl->hint_flags = flags;
1250 size_hints.length = sizeof (size_hints);
1257 geom.min_width = min_width;
1258 geom.min_height = min_height;
1259 geom.max_width = max_width;
1260 geom.max_height = max_height;
1262 if (flags & GDK_HINT_POS)
1264 if (!GetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1265 WIN32_API_FAILED ("GetWindowPlacement");
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
1279 rect.right = rect.left + 200; /* dummy */
1280 rect.bottom = rect.top + 200;
1281 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1282 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1283 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1284 size_hints.flags = 0;
1285 size_hints.showCmd = SW_SHOWNA;
1287 /* Set the normal position hint to that location, with unchanged
1290 diff = size_hints.rcNormalPosition.left - rect.left;
1291 size_hints.rcNormalPosition.left = rect.left;
1292 size_hints.rcNormalPosition.right -= diff;
1293 diff = size_hints.rcNormalPosition.top - rect.top;
1294 size_hints.rcNormalPosition.top = rect.top;
1295 size_hints.rcNormalPosition.bottom -= diff;
1296 GDK_NOTE (MISC, g_print ("...setting: (%ld,%ld)--(%ld,%ld)\n",
1297 size_hints.rcNormalPosition.left,
1298 size_hints.rcNormalPosition.top,
1299 size_hints.rcNormalPosition.right,
1300 size_hints.rcNormalPosition.bottom));
1301 if (!SetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1302 WIN32_API_FAILED ("SetWindowPlacement");
1303 impl->hint_x = rect.left;
1304 impl->hint_y = rect.top;
1308 if (flags & GDK_HINT_MIN_SIZE)
1309 geom_mask |= GDK_HINT_MIN_SIZE;
1311 if (flags & GDK_HINT_MAX_SIZE)
1312 geom_mask |= GDK_HINT_MAX_SIZE;
1314 gdk_window_set_geometry_hints (window, &geom, geom_mask);
1319 gdk_window_set_geometry_hints (GdkWindow *window,
1320 GdkGeometry *geometry,
1321 GdkWindowHints geom_mask)
1323 GdkWindowImplWin32 *impl;
1324 WINDOWPLACEMENT size_hints;
1328 gint new_width = 0, new_height = 0;
1330 g_return_if_fail (window != NULL);
1331 g_return_if_fail (GDK_IS_WINDOW (window));
1333 if (GDK_WINDOW_DESTROYED (window))
1336 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1337 size_hints.length = sizeof (size_hints);
1339 impl->hint_flags = geom_mask;
1341 if (geom_mask & GDK_HINT_POS)
1342 ; /* even the X11 mplementation doesn't care */
1344 if (geom_mask & GDK_HINT_MIN_SIZE)
1348 rect.right = geometry->min_width;
1349 rect.bottom = geometry->min_height;
1350 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1351 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1352 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1353 impl->hint_min_width = rect.right - rect.left;
1354 impl->hint_min_height = rect.bottom - rect.top;
1356 /* Also check if he current size of the window is in bounds */
1357 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1359 if (rect.right < geometry->min_width
1360 && rect.bottom < geometry->min_height)
1362 new_width = geometry->min_width; new_height = geometry->min_height;
1364 else if (rect.right < geometry->min_width)
1366 new_width = geometry->min_width; new_height = rect.bottom;
1368 else if (rect.bottom < geometry->min_height)
1370 new_width = rect.right; new_height = geometry->min_height;
1374 if (geom_mask & GDK_HINT_MAX_SIZE)
1378 rect.right = geometry->max_width;
1379 rect.bottom = geometry->max_height;
1380 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1381 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1382 /* HB: dont' know why AdjustWindowRectEx is called here, ... */
1383 SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1384 impl->hint_max_width = rect.right - rect.left;
1385 impl->hint_max_height = rect.bottom - rect.top;
1386 /* ... but negative sizes are always wrong */
1387 if (impl->hint_max_width < 0) impl->hint_max_width = G_MAXSHORT;
1388 if (impl->hint_max_height < 0) impl->hint_max_height = G_MAXSHORT;
1390 /* Again, check if the window is too large currently. */
1391 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1392 if (rect.right > geometry->max_width
1393 && rect.bottom > geometry->max_height)
1395 new_width = geometry->max_width; new_height = geometry->max_height;
1397 else if (rect.right > geometry->max_width)
1399 new_width = geometry->max_width; new_height = rect.bottom;
1401 else if (rect.bottom > geometry->max_height)
1403 new_width = rect.right; new_height = geometry->max_height;
1407 /* finally apply new size constraints */
1408 if (new_width != 0 && new_height != 0)
1409 gdk_window_resize (window, new_width, new_height);
1411 /* I don't know what to do when called with zero base_width and height. */
1412 if (geom_mask & GDK_HINT_BASE_SIZE
1413 && geometry->base_width > 0
1414 && geometry->base_height > 0)
1416 if (!GetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1417 WIN32_API_FAILED ("GetWindowPlacement");
1420 GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
1421 " rcNormalPosition: (%ld,%ld)--(%ld,%ld)\n",
1422 size_hints.rcNormalPosition.left,
1423 size_hints.rcNormalPosition.top,
1424 size_hints.rcNormalPosition.right,
1425 size_hints.rcNormalPosition.bottom));
1426 size_hints.rcNormalPosition.right =
1427 size_hints.rcNormalPosition.left + geometry->base_width;
1428 size_hints.rcNormalPosition.bottom =
1429 size_hints.rcNormalPosition.top + geometry->base_height;
1430 GDK_NOTE (MISC, g_print ("...setting: rcNormal: (%ld,%ld)--(%ld,%ld)\n",
1431 size_hints.rcNormalPosition.left,
1432 size_hints.rcNormalPosition.top,
1433 size_hints.rcNormalPosition.right,
1434 size_hints.rcNormalPosition.bottom));
1435 if (!SetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1436 WIN32_API_FAILED ("SetWindowPlacement");
1440 if (geom_mask & GDK_HINT_RESIZE_INC)
1445 if (geom_mask & GDK_HINT_ASPECT)
1452 gdk_window_set_title (GdkWindow *window,
1457 g_return_if_fail (window != NULL);
1458 g_return_if_fail (GDK_IS_WINDOW (window));
1459 g_return_if_fail (title != NULL);
1461 /* Empty window titles not allowed, so set it to just a period. */
1465 GDK_NOTE (MISC, g_print ("gdk_window_set_title: %p %s\n",
1466 GDK_WINDOW_HWND (window), title));
1468 if (!GDK_WINDOW_DESTROYED (window))
1470 /* As the title is in UTF-8 we must translate it
1471 * to the system codepage.
1473 mbtitle = g_locale_from_utf8 (title, -1, NULL, NULL, NULL);
1474 if (!SetWindowText (GDK_WINDOW_HWND (window), mbtitle))
1475 WIN32_API_FAILED ("SetWindowText");
1482 gdk_window_set_role (GdkWindow *window,
1485 g_return_if_fail (window != NULL);
1486 g_return_if_fail (GDK_IS_WINDOW (window));
1488 GDK_NOTE (MISC, g_print ("gdk_window_set_role: %p %s\n",
1489 GDK_WINDOW_HWND (window),
1490 (role ? role : "NULL")));
1495 gdk_window_set_transient_for (GdkWindow *window,
1498 HWND window_id, parent_id;
1501 g_return_if_fail (window != NULL);
1502 g_return_if_fail (GDK_IS_WINDOW (window));
1504 GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %p %p\n",
1505 GDK_WINDOW_HWND (window),
1506 GDK_WINDOW_HWND (parent)));
1508 if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (parent))
1511 window_id = GDK_WINDOW_HWND (window);
1512 parent_id = GDK_WINDOW_HWND (parent);
1514 if ((style = GetWindowLong (window_id, GWL_STYLE)) == 0)
1515 WIN32_API_FAILED ("GetWindowLong");
1518 #if 0 /* not sure if we want to do this */
1519 style &= ~(WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX);
1522 if (!SetWindowLong (window_id, GWL_STYLE, style))
1523 WIN32_API_FAILED ("SetWindowLong");
1524 #if 0 /* not sure if we want to do this, clipping to parent size! */
1525 if (!SetParent (window_id, parent_id))
1526 WIN32_API_FAILED ("SetParent");
1527 #else /* make the modal window topmost instead */
1528 if (!SetWindowPos (window_id, HWND_NOTOPMOST, 0, 0, 0, 0,
1529 SWP_NOMOVE | SWP_NOSIZE))
1530 WIN32_API_FAILED ("SetWindowPos");
1533 if (!RedrawWindow (window_id, NULL, NULL,
1534 RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW))
1535 WIN32_API_FAILED ("RedrawWindow");
1539 gdk_window_set_background (GdkWindow *window,
1542 GdkWindowObject *private = (GdkWindowObject *)window;
1544 g_return_if_fail (window != NULL);
1545 g_return_if_fail (GDK_IS_WINDOW (window));
1547 GDK_NOTE (MISC, g_print ("gdk_window_set_background: %p %s\n",
1548 GDK_WINDOW_HWND (window),
1549 gdk_win32_color_to_string (color)));
1551 private->bg_color = *color;
1553 if (private->bg_pixmap &&
1554 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1555 private->bg_pixmap != GDK_NO_BG)
1557 gdk_drawable_unref (private->bg_pixmap);
1558 private->bg_pixmap = NULL;
1563 gdk_window_set_back_pixmap (GdkWindow *window,
1565 gint parent_relative)
1567 GdkWindowObject *private = (GdkWindowObject *)window;
1569 g_return_if_fail (window != NULL);
1570 g_return_if_fail (GDK_IS_WINDOW (window));
1571 g_return_if_fail (pixmap == NULL || !parent_relative);
1572 g_return_if_fail (pixmap == NULL || gdk_drawable_get_depth (window) == gdk_drawable_get_depth (pixmap));
1574 if (private->bg_pixmap &&
1575 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1576 private->bg_pixmap != GDK_NO_BG)
1577 gdk_drawable_unref (private->bg_pixmap);
1579 if (parent_relative)
1581 private->bg_pixmap = GDK_PARENT_RELATIVE_BG;
1582 GDK_NOTE (MISC, g_print (G_STRLOC ": setting background pixmap to parent_relative\n"));
1588 gdk_drawable_ref (pixmap);
1589 private->bg_pixmap = pixmap;
1593 private->bg_pixmap = GDK_NO_BG;
1599 gdk_window_set_cursor (GdkWindow *window,
1602 GdkWindowImplWin32 *impl;
1603 GdkCursorPrivate *cursor_private;
1604 GdkWindowObject *parent_window;
1606 HCURSOR hprevcursor;
1608 g_return_if_fail (window != NULL);
1609 g_return_if_fail (GDK_IS_WINDOW (window));
1611 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1612 cursor_private = (GdkCursorPrivate*) cursor;
1614 if (GDK_WINDOW_DESTROYED (window))
1620 hcursor = cursor_private->hcursor;
1622 GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %p %p\n",
1623 GDK_WINDOW_HWND (window),
1626 /* First get the old cursor, if any (we wait to free the old one
1627 * since it may be the current cursor set in the Win32 API right
1630 hprevcursor = impl->hcursor;
1632 if (hcursor == NULL)
1633 impl->hcursor = NULL;
1636 /* We must copy the cursor as it is OK to destroy the GdkCursor
1637 * while still in use for some window. See for instance
1638 * gimp_change_win_cursor() which calls gdk_window_set_cursor
1639 * (win, cursor), and immediately afterwards gdk_cursor_destroy
1642 if ((impl->hcursor = CopyCursor (hcursor)) == NULL)
1643 WIN32_API_FAILED ("CopyCursor");
1644 GDK_NOTE (MISC, g_print ("...CopyCursor (%p) = %p\n",
1645 hcursor, impl->hcursor));
1648 /* If the pointer is over our window, set new cursor if given */
1649 if (gdk_window_get_pointer(window, NULL, NULL, NULL) == window)
1650 if (impl->hcursor != NULL)
1651 SetCursor (impl->hcursor);
1653 /* Destroy the previous cursor: Need to make sure it's no longer in
1654 * use before we destroy it, in case we're not over our window but
1655 * the cursor is still set to our old one.
1657 if (hprevcursor != NULL)
1659 if (GetCursor() == hprevcursor)
1661 /* Look for a suitable cursor to use instead */
1663 parent_window = GDK_WINDOW_OBJECT (window)->parent;
1664 while (hcursor == NULL)
1668 impl = GDK_WINDOW_IMPL_WIN32 (parent_window->impl);
1669 hcursor = impl->hcursor;
1670 parent_window = parent_window->parent;
1674 hcursor = LoadCursor (NULL, IDC_ARROW);
1677 SetCursor (hcursor);
1680 GDK_NOTE (MISC, g_print ("...DestroyCursor (%p)\n",
1683 if (!DestroyCursor (hprevcursor))
1684 WIN32_API_FAILED ("DestroyCursor");
1689 gdk_window_get_geometry (GdkWindow *window,
1696 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1699 window = _gdk_parent_root;
1701 if (!GDK_WINDOW_DESTROYED (window))
1705 if (!GetClientRect (GDK_WINDOW_HWND (window), &rect))
1706 WIN32_API_FAILED ("GetClientRect");
1713 *width = rect.right - rect.left;
1715 *height = rect.bottom - rect.top;
1717 *depth = gdk_drawable_get_visual (window)->depth;
1722 gdk_window_get_origin (GdkWindow *window,
1730 g_return_val_if_fail (window != NULL, 0);
1732 if (!GDK_WINDOW_DESTROYED (window))
1738 ClientToScreen (GDK_WINDOW_HWND (window), &pt);
1751 GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %p: +%d+%d\n",
1752 GDK_WINDOW_HWND (window),
1758 gdk_window_get_deskrelative_origin (GdkWindow *window,
1762 return gdk_window_get_origin (window, x, y);
1766 gdk_window_get_root_origin (GdkWindow *window,
1772 g_return_if_fail (GDK_IS_WINDOW (window));
1774 gdk_window_get_frame_extents (window, &rect);
1784 gdk_window_get_frame_extents (GdkWindow *window,
1787 GdkWindowObject *private;
1791 g_return_if_fail (GDK_IS_WINDOW (window));
1792 g_return_if_fail (rect != NULL);
1794 private = GDK_WINDOW_OBJECT (window);
1801 if (GDK_WINDOW_DESTROYED (window))
1804 while (private->parent && ((GdkWindowObject*) private->parent)->parent)
1805 private = (GdkWindowObject*) private->parent;
1807 hwnd = GDK_WINDOW_HWND (window);
1809 /* find the frame window */
1810 while (HWND_DESKTOP != GetParent (hwnd))
1812 hwnd = GetParent (hwnd);
1813 g_return_if_fail (NULL != hwnd);
1816 if (!GetWindowRect (hwnd, &r))
1817 WIN32_API_FAILED ("GetWindowRect");
1821 rect->width = r.right - r.left;
1822 rect->height = r.bottom - r.top;
1826 _gdk_windowing_window_get_pointer (GdkWindow *window,
1829 GdkModifierType *mask)
1831 GdkWindow *return_val;
1832 POINT screen_point, point;
1836 g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1839 GetCursorPos (&screen_point);
1840 point = screen_point;
1841 ScreenToClient (GDK_WINDOW_HWND (window), &point);
1846 hwnd = WindowFromPoint (point);
1849 gboolean done = FALSE;
1853 point = screen_point;
1854 ScreenToClient (hwnd, &point);
1855 hwndc = ChildWindowFromPoint (hwnd, point);
1858 else if (hwndc == hwnd)
1864 return_val = gdk_window_lookup ((GdkNativeWindow) hwnd);
1869 GetKeyboardState (kbd);
1871 if (kbd[VK_SHIFT] & 0x80)
1872 *mask |= GDK_SHIFT_MASK;
1873 if (kbd[VK_CAPITAL] & 0x80)
1874 *mask |= GDK_LOCK_MASK;
1875 if (kbd[VK_CONTROL] & 0x80)
1876 *mask |= GDK_CONTROL_MASK;
1877 if (kbd[VK_MENU] & 0x80)
1878 *mask |= GDK_MOD1_MASK;
1879 if (kbd[VK_LBUTTON] & 0x80)
1880 *mask |= GDK_BUTTON1_MASK;
1881 if (kbd[VK_MBUTTON] & 0x80)
1882 *mask |= GDK_BUTTON2_MASK;
1883 if (kbd[VK_RBUTTON] & 0x80)
1884 *mask |= GDK_BUTTON3_MASK;
1890 _gdk_windowing_get_pointer (GdkDisplay *display,
1894 GdkModifierType *mask)
1896 GdkScreen *default_screen = gdk_display_get_default_screen (display);
1897 GdkWindow *root_window = gdk_screen_get_root_window (screen);
1899 *screen = default_screen;
1900 _gdk_windowing_window_get_pointer (root_window, x, y, mask);
1904 _gdk_windowing_window_at_pointer (GdkDisplay *display,
1909 POINT point, pointc;
1913 GetCursorPos (&pointc);
1915 hwnd = WindowFromPoint (point);
1919 window = _gdk_parent_root;
1925 ScreenToClient (hwnd, &point);
1928 hwndc = ChildWindowFromPoint (hwnd, point);
1929 ClientToScreen (hwnd, &point);
1930 ScreenToClient (hwndc, &point);
1931 } while (hwndc != hwnd && (hwnd = hwndc, 1));
1933 window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
1935 if (window && (win_x || win_y))
1937 GetClientRect (hwnd, &rect);
1938 *win_x = point.x - rect.left;
1939 *win_y = point.y - rect.top;
1942 GDK_NOTE (MISC, g_print ("gdk_window_at_pointer: +%ld+%ld %p%s\n",
1945 (window == NULL ? " NULL" : "")));
1951 gdk_window_get_events (GdkWindow *window)
1953 g_return_val_if_fail (window != NULL, 0);
1954 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
1956 if (GDK_WINDOW_DESTROYED (window))
1959 return GDK_WINDOW_OBJECT (window)->event_mask;
1963 gdk_window_set_events (GdkWindow *window,
1964 GdkEventMask event_mask)
1966 g_return_if_fail (window != NULL);
1967 g_return_if_fail (GDK_IS_WINDOW (window));
1969 if (GDK_WINDOW_DESTROYED (window))
1972 /* gdk_window_new() always sets the GDK_STRUCTURE_MASK, so better
1973 * set it here, too. Not that I know or remember why it is
1974 * necessary, will have to test some day.
1976 GDK_WINDOW_OBJECT (window)->event_mask = GDK_STRUCTURE_MASK | event_mask;
1980 gdk_window_shape_combine_mask (GdkWindow *window,
1984 g_return_if_fail (window != NULL);
1985 g_return_if_fail (GDK_IS_WINDOW (window));
1989 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %p none\n",
1990 GDK_WINDOW_HWND (window)));
1991 SetWindowRgn (GDK_WINDOW_HWND (window), NULL, TRUE);
2000 /* Convert mask bitmap to region */
2001 hrgn = _gdk_win32_bitmap_to_region (mask);
2003 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %p %p\n",
2004 GDK_WINDOW_HWND (window),
2005 GDK_WINDOW_HWND (mask)));
2007 /* SetWindowRgn wants window (not client) coordinates */
2008 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
2009 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
2010 GetClientRect (GDK_WINDOW_HWND (window), &rect);
2011 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
2012 OffsetRgn (hrgn, -rect.left, -rect.top);
2014 OffsetRgn (hrgn, x, y);
2016 /* If this is a top-level window, add the title bar to the region */
2017 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL)
2019 HRGN tmp = CreateRectRgn (0, 0, rect.right - rect.left, -rect.top);
2020 CombineRgn (hrgn, hrgn, tmp, RGN_OR);
2024 SetWindowRgn (GDK_WINDOW_HWND (window), hrgn, TRUE);
2029 gdk_window_set_override_redirect (GdkWindow *window,
2030 gboolean override_redirect)
2032 g_return_if_fail (window != NULL);
2033 g_return_if_fail (GDK_IS_WINDOW (window));
2035 g_warning ("gdk_window_set_override_redirect not implemented");
2039 gdk_window_set_icon_list (GdkWindow *window,
2042 g_return_if_fail (GDK_IS_WINDOW (window));
2044 if (GDK_WINDOW_DESTROYED (window))
2047 /* We could convert it to a hIcon and DrawIcon () it when getting
2048 * a WM_PAINT with IsIconic, but is it worth it ? Same probably
2049 * goes for gdk_window_set_icon (). Patches accepted :-) --hb
2050 * Or do we only need to deliver the Icon on WM_GETICON ?
2055 gdk_window_set_icon (GdkWindow *window,
2056 GdkWindow *icon_window,
2060 g_return_if_fail (window != NULL);
2061 g_return_if_fail (GDK_IS_WINDOW (window));
2063 if (GDK_WINDOW_DESTROYED (window))
2066 /* Nothing to do, really. As we share window classes between windows
2067 * we can't have window-specific icons, sorry. Don't print any warning
2073 gdk_window_set_icon_name (GdkWindow *window,
2076 g_return_if_fail (window != NULL);
2077 g_return_if_fail (GDK_IS_WINDOW (window));
2079 if (GDK_WINDOW_DESTROYED (window))
2082 if (!SetWindowText (GDK_WINDOW_HWND (window), name))
2083 WIN32_API_FAILED ("SetWindowText");
2087 gdk_window_set_group (GdkWindow *window,
2090 g_return_if_fail (window != NULL);
2091 g_return_if_fail (GDK_IS_WINDOW (window));
2092 g_return_if_fail (leader != NULL);
2093 g_return_if_fail (GDK_IS_WINDOW (leader));
2095 if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (leader))
2098 g_warning ("gdk_window_set_group not implemented");
2102 gdk_window_set_decorations (GdkWindow *window,
2103 GdkWMDecoration decorations)
2105 LONG style, exstyle;
2107 g_return_if_fail (window != NULL);
2108 g_return_if_fail (GDK_IS_WINDOW (window));
2110 style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
2111 exstyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
2113 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
2114 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
2116 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
2118 if (decorations & GDK_DECOR_ALL)
2119 style |= (WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
2120 if (decorations & GDK_DECOR_BORDER)
2121 style |= (WS_BORDER);
2122 if (decorations & GDK_DECOR_RESIZEH)
2123 style |= (WS_THICKFRAME);
2124 if (decorations & GDK_DECOR_TITLE)
2125 style |= (WS_CAPTION);
2126 if (decorations & GDK_DECOR_MENU)
2127 style |= (WS_SYSMENU);
2128 if (decorations & GDK_DECOR_MINIMIZE)
2129 style |= (WS_MINIMIZEBOX);
2130 if (decorations & GDK_DECOR_MAXIMIZE)
2131 style |= (WS_MAXIMIZEBOX);
2133 SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
2137 gdk_window_set_functions (GdkWindow *window,
2138 GdkWMFunction functions)
2140 LONG style, exstyle;
2142 g_return_if_fail (window != NULL);
2143 g_return_if_fail (GDK_IS_WINDOW (window));
2145 style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
2146 exstyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
2148 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
2149 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
2152 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
2154 if (functions & GDK_FUNC_ALL)
2155 style |= (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
2156 if (functions & GDK_FUNC_RESIZE)
2157 style |= (WS_THICKFRAME);
2158 if (functions & GDK_FUNC_MOVE)
2159 style |= (WS_THICKFRAME);
2160 if (functions & GDK_FUNC_MINIMIZE)
2161 style |= (WS_MINIMIZEBOX);
2162 if (functions & GDK_FUNC_MAXIMIZE)
2163 style |= (WS_MAXIMIZEBOX);
2165 SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
2169 * propagate the shapes from all child windows of a GDK window to the parent
2170 * window. Shamelessly ripped from Enlightenment's code
2176 QueryTree (HWND hwnd,
2186 child = GetWindow (hwnd, GW_CHILD);
2188 child = GetWindow (child, GW_HWNDNEXT);
2191 } while (child != NULL);
2195 *children = g_new (HWND, n);
2196 for (i = 0; i < n; i++)
2199 child = GetWindow (hwnd, GW_CHILD);
2201 child = GetWindow (child, GW_HWNDNEXT);
2202 *children[i] = child;
2208 gdk_propagate_shapes (HANDLE win,
2212 HRGN region, childRegion;
2216 SetRectEmpty (&emptyRect);
2217 region = CreateRectRgnIndirect (&emptyRect);
2219 GetWindowRgn (win, region);
2221 QueryTree (win, &list, &num);
2224 WINDOWPLACEMENT placement;
2226 placement.length = sizeof (WINDOWPLACEMENT);
2227 /* go through all child windows and combine regions */
2228 for (i = 0; i < num; i++)
2230 GetWindowPlacement (list[i], &placement);
2231 if (placement.showCmd == SW_SHOWNORMAL)
2233 childRegion = CreateRectRgnIndirect (&emptyRect);
2234 GetWindowRgn (list[i], childRegion);
2235 CombineRgn (region, region, childRegion, RGN_OR);
2236 DeleteObject (childRegion);
2239 SetWindowRgn (win, region, TRUE);
2242 DeleteObject (region);
2246 gdk_window_set_child_shapes (GdkWindow *window)
2248 g_return_if_fail (window != NULL);
2249 g_return_if_fail (GDK_IS_WINDOW (window));
2251 if (GDK_WINDOW_DESTROYED (window))
2254 gdk_propagate_shapes (GDK_WINDOW_HWND (window), FALSE);
2258 gdk_window_merge_child_shapes (GdkWindow *window)
2260 g_return_if_fail (window != NULL);
2261 g_return_if_fail (GDK_IS_WINDOW (window));
2263 if (GDK_WINDOW_DESTROYED (window))
2266 gdk_propagate_shapes (GDK_WINDOW_HWND (window), TRUE);
2269 /* Support for windows that can be guffaw-scrolled
2270 * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
2274 gdk_window_gravity_works (void)
2276 enum { UNKNOWN, NO, YES };
2277 static gint gravity_works = UNKNOWN;
2279 if (gravity_works == UNKNOWN)
2286 attr.window_type = GDK_WINDOW_TEMP;
2287 attr.wclass = GDK_INPUT_OUTPUT;
2292 attr.event_mask = 0;
2294 parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
2296 attr.window_type = GDK_WINDOW_CHILD;
2297 child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
2299 gdk_window_set_static_win_gravity (child, TRUE);
2301 gdk_window_resize (parent, 100, 110);
2302 gdk_window_move (parent, 0, -10);
2303 gdk_window_move_resize (parent, 0, 0, 100, 100);
2305 gdk_window_resize (parent, 100, 110);
2306 gdk_window_move (parent, 0, -10);
2307 gdk_window_move_resize (parent, 0, 0, 100, 100);
2309 gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
2311 gdk_window_destroy (parent);
2312 gdk_window_destroy (child);
2314 gravity_works = ((y == -20) ? YES : NO);
2317 return (gravity_works == YES);
2321 gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
2323 g_return_if_fail (window != NULL);
2325 GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
2329 gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
2331 g_return_if_fail (window != NULL);
2333 GDK_NOTE (MISC, g_print ("gdk_window_set_static_win_gravity: Not implemented\n"));
2336 /*************************************************************
2337 * gdk_window_set_static_gravities:
2338 * Set the bit gravity of the given window to static,
2339 * and flag it so all children get static subwindow
2342 * window: window for which to set static gravity
2343 * use_static: Whether to turn static gravity on or off.
2345 * Does the XServer support static gravity?
2346 *************************************************************/
2349 gdk_window_set_static_gravities (GdkWindow *window,
2350 gboolean use_static)
2352 GdkWindowObject *private = (GdkWindowObject *)window;
2355 g_return_val_if_fail (window != NULL, FALSE);
2356 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2358 if (!use_static == !private->guffaw_gravity)
2361 if (use_static && !gdk_window_gravity_works ())
2364 private->guffaw_gravity = use_static;
2366 if (!GDK_WINDOW_DESTROYED (window))
2368 gdk_window_set_static_bit_gravity (window, use_static);
2370 tmp_list = private->children;
2373 gdk_window_set_static_win_gravity (window, use_static);
2375 tmp_list = tmp_list->next;
2383 * Setting window states
2386 gdk_window_iconify (GdkWindow *window)
2388 g_return_if_fail (window != NULL);
2389 g_return_if_fail (GDK_IS_WINDOW (window));
2391 if (GDK_WINDOW_DESTROYED (window))
2394 if (GDK_WINDOW_IS_MAPPED (window))
2396 ShowWindow (GDK_WINDOW_HWND (window), SW_MINIMIZE);
2400 /* Flip our client side flag, the real work happens on map. */
2401 gdk_synthesize_window_state (window,
2403 GDK_WINDOW_STATE_ICONIFIED);
2408 gdk_window_deiconify (GdkWindow *window)
2410 g_return_if_fail (window != NULL);
2411 g_return_if_fail (GDK_IS_WINDOW (window));
2413 if (GDK_WINDOW_DESTROYED (window))
2416 if (GDK_WINDOW_IS_MAPPED (window))
2418 gdk_window_show (window);
2422 /* Flip our client side flag, the real work happens on map. */
2423 gdk_synthesize_window_state (window,
2424 GDK_WINDOW_STATE_ICONIFIED,
2430 gdk_window_stick (GdkWindow *window)
2432 g_return_if_fail (GDK_IS_WINDOW (window));
2434 if (GDK_WINDOW_DESTROYED (window))
2437 if (GDK_WINDOW_IS_MAPPED (window))
2439 /* "stick" means stick to all desktops _and_ do not scroll with the
2440 * viewport. i.e. glue to the monitor glass in all cases.
2442 g_warning ("gdk_window_stick (%p) ???", GDK_WINDOW_HWND (window));
2446 /* Flip our client side flag, the real work happens on map. */
2447 gdk_synthesize_window_state (window,
2449 GDK_WINDOW_STATE_STICKY);
2454 gdk_window_unstick (GdkWindow *window)
2456 g_return_if_fail (GDK_IS_WINDOW (window));
2458 if (GDK_WINDOW_DESTROYED (window))
2461 if (GDK_WINDOW_IS_MAPPED (window))
2463 g_warning ("gdk_window_unstick (%p) ???", GDK_WINDOW_HWND (window));
2467 /* Flip our client side flag, the real work happens on map. */
2468 gdk_synthesize_window_state (window,
2469 GDK_WINDOW_STATE_STICKY,
2475 gdk_window_maximize (GdkWindow *window)
2477 g_return_if_fail (GDK_IS_WINDOW (window));
2479 if (GDK_WINDOW_DESTROYED (window))
2482 if (GDK_WINDOW_IS_MAPPED (window))
2483 ShowWindow (GDK_WINDOW_HWND (window), SW_MAXIMIZE);
2485 gdk_synthesize_window_state (window,
2487 GDK_WINDOW_STATE_MAXIMIZED);
2491 gdk_window_unmaximize (GdkWindow *window)
2493 g_return_if_fail (GDK_IS_WINDOW (window));
2495 if (GDK_WINDOW_DESTROYED (window))
2498 if (GDK_WINDOW_IS_MAPPED (window))
2499 ShowWindow (GDK_WINDOW_HWND (window), SW_RESTORE);
2501 gdk_synthesize_window_state (window,
2502 GDK_WINDOW_STATE_MAXIMIZED,
2507 gdk_window_focus (GdkWindow *window,
2510 g_return_if_fail (GDK_IS_WINDOW (window));
2512 if (GDK_WINDOW_DESTROYED (window))
2515 GDK_NOTE (MISC, g_print ("gdk_window_focus: %p\n", GDK_WINDOW_HWND (window)));
2517 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNORMAL);
2518 SetFocus (GDK_WINDOW_HWND (window));
2522 gdk_window_set_modal_hint (GdkWindow *window,
2525 GdkWindowObject *private;
2527 g_return_if_fail (window != NULL);
2528 g_return_if_fail (GDK_IS_WINDOW (window));
2530 if (GDK_WINDOW_DESTROYED (window))
2533 private = (GdkWindowObject*) window;
2535 private->modal_hint = modal;
2537 if (GDK_WINDOW_IS_MAPPED (window))
2538 if (!SetWindowPos (GDK_WINDOW_HWND (window), HWND_TOPMOST,
2539 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE))
2540 WIN32_API_FAILED ("SetWindowPos");
2544 gdk_window_set_type_hint (GdkWindow *window,
2545 GdkWindowTypeHint hint)
2547 g_return_if_fail (window != NULL);
2548 g_return_if_fail (GDK_IS_WINDOW (window));
2550 if (GDK_WINDOW_DESTROYED (window))
2555 case GDK_WINDOW_TYPE_HINT_DIALOG:
2557 case GDK_WINDOW_TYPE_HINT_MENU:
2559 case GDK_WINDOW_TYPE_HINT_TOOLBAR:
2562 g_warning ("Unknown hint %d passed to gdk_window_set_type_hint", hint);
2564 case GDK_WINDOW_TYPE_HINT_NORMAL:
2570 GDK_NOTE (MISC, g_print ("gdk_window_set_type_hint (%p)\n",
2571 GDK_WINDOW_HWND (window)));
2575 gdk_window_shape_combine_region (GdkWindow *window,
2576 GdkRegion *shape_region,
2580 g_return_if_fail (GDK_IS_WINDOW (window));
2582 if (GDK_WINDOW_DESTROYED (window))
2585 /* XXX: even on X implemented conditional ... */
2589 gdk_window_begin_resize_drag (GdkWindow *window,
2596 g_return_if_fail (GDK_IS_WINDOW (window));
2598 if (GDK_WINDOW_DESTROYED (window))
2601 /* XXX: isn't all this default on win32 ... */
2605 gdk_window_begin_move_drag (GdkWindow *window,
2611 g_return_if_fail (GDK_IS_WINDOW (window));
2613 if (GDK_WINDOW_DESTROYED (window))
2616 /* XXX: isn't all this default on win32 ... */
2620 gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
2622 g_return_val_if_fail (display == gdk_display_get_default(), NULL);
2624 return gdk_window_lookup (anid);