1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 * Copyright (C) 1998-1999 Tor Lillqvist
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 "gdkevents.h"
31 #include "gdkpixmap.h"
32 #include "gdkwindow.h"
33 #include "gdkinternals.h"
34 #include "gdkprivate-win32.h"
35 #include "gdkinput-win32.h"
37 static gboolean gdk_window_gravity_works (void);
38 static void gdk_window_set_static_win_gravity (GdkWindow *window,
41 static GdkColormap* gdk_window_impl_win32_get_colormap (GdkDrawable *drawable);
42 static void gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
44 static void gdk_window_impl_win32_get_size (GdkDrawable *drawable,
47 static GdkRegion* gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable);
48 static void gdk_window_impl_win32_init (GdkWindowImplWin32 *window);
49 static void gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass);
50 static void gdk_window_impl_win32_finalize (GObject *object);
52 static gpointer parent_class = NULL;
55 gdk_window_impl_win32_get_type (void)
57 static GType object_type = 0;
61 static const GTypeInfo object_info =
63 sizeof (GdkWindowImplWin32Class),
65 (GBaseFinalizeFunc) NULL,
66 (GClassInitFunc) gdk_window_impl_win32_class_init,
67 NULL, /* class_finalize */
68 NULL, /* class_data */
69 sizeof (GdkWindowImplWin32),
71 (GInstanceInitFunc) gdk_window_impl_win32_init,
74 object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_WIN32,
83 _gdk_window_impl_get_type (void)
85 return gdk_window_impl_win32_get_type ();
89 gdk_window_impl_win32_init (GdkWindowImplWin32 *impl)
97 impl->extension_events_selected = FALSE;
98 impl->input_locale = GetKeyboardLayout (0);
99 TranslateCharsetInfo ((DWORD FAR *) GetACP (), &impl->charset_info,
104 gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass)
106 GObjectClass *object_class = G_OBJECT_CLASS (klass);
107 GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
109 parent_class = g_type_class_peek_parent (klass);
111 object_class->finalize = gdk_window_impl_win32_finalize;
113 drawable_class->set_colormap = gdk_window_impl_win32_set_colormap;
114 drawable_class->get_colormap = gdk_window_impl_win32_get_colormap;
115 drawable_class->get_size = gdk_window_impl_win32_get_size;
117 /* Visible and clip regions are the same */
118 drawable_class->get_clip_region = gdk_window_impl_win32_get_visible_region;
119 drawable_class->get_visible_region = gdk_window_impl_win32_get_visible_region;
123 gdk_window_impl_win32_finalize (GObject *object)
125 GdkWindowObject *wrapper;
126 GdkDrawableImplWin32 *draw_impl;
127 GdkWindowImplWin32 *window_impl;
129 g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (object));
131 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (object);
132 window_impl = GDK_WINDOW_IMPL_WIN32 (object);
134 wrapper = (GdkWindowObject*) draw_impl->wrapper;
136 if (!GDK_WINDOW_DESTROYED (wrapper))
138 gdk_win32_handle_table_remove (draw_impl->handle);
141 if (window_impl->hcursor != NULL)
143 if (!DestroyCursor (window_impl->hcursor))
144 WIN32_GDI_FAILED("DestroyCursor");
145 window_impl->hcursor = NULL;
148 G_OBJECT_CLASS (parent_class)->finalize (object);
152 gdk_window_impl_win32_get_colormap (GdkDrawable *drawable)
154 GdkDrawableImplWin32 *drawable_impl;
155 GdkWindowImplWin32 *window_impl;
157 g_return_val_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable), NULL);
159 drawable_impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
160 window_impl = GDK_WINDOW_IMPL_WIN32 (drawable);
162 if (!((GdkWindowObject *) drawable_impl->wrapper)->input_only &&
163 drawable_impl->colormap == NULL)
165 drawable_impl->colormap = gdk_colormap_get_system ();
166 gdk_colormap_ref (drawable_impl->colormap);
169 return drawable_impl->colormap;
173 gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
176 GdkWindowImplWin32 *impl;
177 GdkDrawableImplWin32 *draw_impl;
179 g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable));
180 g_return_if_fail (gdk_colormap_get_visual (cmap) != gdk_drawable_get_visual (drawable));
182 impl = GDK_WINDOW_IMPL_WIN32 (drawable);
183 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
185 GDK_DRAWABLE_GET_CLASS (draw_impl)->set_colormap (drawable, cmap);
188 g_print("gdk_window_impl_win32_set_colormap: XXX\n");
192 gdk_window_impl_win32_get_size (GdkDrawable *drawable,
196 g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (drawable));
199 *width = GDK_WINDOW_IMPL_WIN32 (drawable)->width;
201 *height = GDK_WINDOW_IMPL_WIN32 (drawable)->height;
205 gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable)
207 GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (drawable);
208 GdkRectangle result_rect;
212 result_rect.width = impl->width;
213 result_rect.height = impl->height;
215 gdk_rectangle_intersect (&result_rect, &impl->position_info.clip_rect, &result_rect);
217 return gdk_region_rectangle (&result_rect);
221 _gdk_windowing_window_init (void)
223 GdkWindowObject *private;
224 GdkWindowImplWin32 *impl;
225 GdkDrawableImplWin32 *draw_impl;
230 g_assert (gdk_parent_root == NULL);
232 SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);
233 width = rect.right - rect.left;
234 height = rect.bottom - rect.top;
236 gdk_parent_root = g_object_new (GDK_TYPE_WINDOW, NULL);
237 private = (GdkWindowObject *)gdk_parent_root;
238 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
239 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
241 draw_impl->handle = gdk_root_window;
242 draw_impl->wrapper = GDK_DRAWABLE (private);
244 private->window_type = GDK_WINDOW_ROOT;
245 private->depth = gdk_visual_get_system ()->depth;
247 impl->height = height;
249 gdk_win32_handle_table_insert (&gdk_root_window, gdk_parent_root);
252 /* The Win API function AdjustWindowRect may return negative values
253 * resulting in obscured title bars. This helper function is coreccting it.
256 SafeAdjustWindowRectEx (RECT* lpRect,
261 if (!AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle))
263 WIN32_API_FAILED ("AdjustWindowRectEx");
266 if (lpRect->left < 0)
268 lpRect->right -= lpRect->left;
273 lpRect->bottom -= lpRect->top;
280 * is a wrapper function for RegisterWindowClassEx.
281 * It creates at least one unique class for every
282 * GdkWindowType. If support for single window-specific icons
283 * is ever needed (e.g Dialog specific), every such window should
287 RegisterGdkClass (GdkWindowType wtype)
289 static ATOM klassTOPLEVEL = 0;
290 static ATOM klassDIALOG = 0;
291 static ATOM klassCHILD = 0;
292 static ATOM klassTEMP = 0;
293 static HICON hAppIcon = NULL;
294 static WNDCLASSEX wcl;
297 wcl.cbSize = sizeof(WNDCLASSEX);
298 wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
299 * on WM_SIZE and WM_MOVE. Flicker, Performance!
301 wcl.lpfnWndProc = gdk_window_procedure;
304 wcl.hInstance = gdk_app_hmodule;
306 /* initialize once! */
309 gchar sLoc [_MAX_PATH+1];
311 if (0 != GetModuleFileName (gdk_app_hmodule, sLoc, _MAX_PATH))
313 hAppIcon = ExtractIcon (gdk_app_hmodule, sLoc, 0);
316 char *gdklibname = g_strdup_printf ("gdk-%s.dll", GDK_VERSION);
318 hAppIcon = ExtractIcon (gdk_app_hmodule, gdklibname, 0);
323 hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
327 wcl.lpszMenuName = NULL;
330 /* initialize once per class */
331 #define ONCE_PER_CLASS() \
332 wcl.hIcon = CopyIcon (hAppIcon); \
333 wcl.hIconSm = CopyIcon (hAppIcon); \
334 wcl.hbrBackground = CreateSolidBrush (RGB (0,0,0)); \
335 wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
339 case GDK_WINDOW_TOPLEVEL:
340 if (0 == klassTOPLEVEL)
342 wcl.lpszClassName = "gdkWindowToplevel";
345 klassTOPLEVEL = RegisterClassEx (&wcl);
347 klass = klassTOPLEVEL;
350 case GDK_WINDOW_CHILD:
353 wcl.lpszClassName = "gdkWindowChild";
355 wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
357 klassCHILD = RegisterClassEx (&wcl);
362 case GDK_WINDOW_DIALOG:
363 if (0 == klassDIALOG)
365 wcl.lpszClassName = "gdkWindowDialog";
366 wcl.style |= CS_SAVEBITS;
368 klassDIALOG = RegisterClassEx (&wcl);
373 case GDK_WINDOW_TEMP:
376 wcl.lpszClassName = "gdkWindowTemp";
377 wcl.style |= CS_SAVEBITS;
379 klassTEMP = RegisterClassEx (&wcl);
385 g_assert_not_reached ();
391 WIN32_API_FAILED ("RegisterClassEx");
392 g_error ("That is a fatal error");
398 gdk_window_new (GdkWindow *parent,
399 GdkWindowAttr *attributes,
400 gint attributes_mask)
403 GdkWindowObject *private;
404 GdkWindowObject *parent_private;
405 GdkWindowImplWin32 *impl;
406 GdkDrawableImplWin32 *draw_impl;
412 DWORD dwStyle, dwExStyle;
421 g_return_val_if_fail (attributes != NULL, NULL);
424 parent = gdk_parent_root;
426 g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
429 g_print ("gdk_window_new: %s\n",
430 (attributes->window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
431 (attributes->window_type == GDK_WINDOW_CHILD ? "CHILD" :
432 (attributes->window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
433 (attributes->window_type == GDK_WINDOW_TEMP ? "TEMP" :
436 parent_private = (GdkWindowObject*) parent;
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 private->parent = (GdkWindowObject *)parent;
450 if (attributes_mask & GDK_WA_X)
455 if (attributes_mask & GDK_WA_Y)
457 else if (attributes_mask & GDK_WA_X)
458 y = 100; /* ??? We must put it somewhere... */
460 y = 0; /* x is CW_USEDEFAULT, y doesn't matter then */
464 impl->width = (attributes->width > 1) ? (attributes->width) : (1);
465 impl->height = (attributes->height > 1) ? (attributes->height) : (1);
466 impl->extension_events_selected = FALSE;
467 private->window_type = attributes->window_type;
469 _gdk_window_init_position (GDK_WINDOW (private));
470 if (impl->position_info.big)
471 private->guffaw_gravity = TRUE;
473 if (attributes_mask & GDK_WA_VISUAL)
474 visual = attributes->visual;
476 visual = gdk_visual_get_system ();
477 xvisual = ((GdkVisualPrivate*) visual)->xvisual;
479 if (attributes_mask & GDK_WA_TITLE)
480 title = attributes->title;
482 title = g_get_prgname ();
483 if (!title || !*title)
484 title = "GDK client window";
486 impl->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
488 if (parent_private && parent_private->guffaw_gravity)
493 if (attributes->wclass == GDK_INPUT_OUTPUT)
497 private->input_only = FALSE;
498 private->depth = visual->depth;
500 if (attributes_mask & GDK_WA_COLORMAP)
502 draw_impl->colormap = attributes->colormap;
503 gdk_colormap_ref (attributes->colormap);
507 if ((((GdkVisualPrivate*)gdk_visual_get_system ())->xvisual) == xvisual)
509 draw_impl->colormap = gdk_colormap_get_system ();
510 gdk_colormap_ref (draw_impl->colormap);
511 GDK_NOTE (MISC, g_print ("...using system colormap %p\n",
512 draw_impl->colormap));
516 draw_impl->colormap = gdk_colormap_new (visual, FALSE);
517 GDK_NOTE (MISC, g_print ("...using new colormap %p\n",
518 draw_impl->colormap));
524 dwExStyle = WS_EX_TRANSPARENT;
526 private->input_only = TRUE;
527 draw_impl->colormap = NULL;
528 GDK_NOTE (MISC, g_print ("...GDK_INPUT_ONLY, NULL colormap\n"));
532 parent_private->children = g_list_prepend (parent_private->children, window);
534 switch (private->window_type)
536 case GDK_WINDOW_TOPLEVEL:
537 dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
538 hparent = gdk_root_window;
541 case GDK_WINDOW_CHILD:
542 dwStyle = WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
545 case GDK_WINDOW_DIALOG:
546 dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
548 dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
550 hparent = gdk_root_window;
553 case GDK_WINDOW_TEMP:
554 dwStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
555 dwExStyle |= WS_EX_TOOLWINDOW;
558 case GDK_WINDOW_ROOT:
559 g_error ("cannot make windows of type GDK_WINDOW_ROOT");
563 klass = RegisterGdkClass (private->window_type);
565 if (private->window_type != GDK_WINDOW_CHILD)
567 if (x == CW_USEDEFAULT)
578 rect.right = rect.left + impl->width;
579 rect.bottom = rect.top + impl->height;
581 SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
583 if (x != CW_USEDEFAULT)
588 width = rect.right - rect.left;
589 height = rect.bottom - rect.top;
594 height = impl->height;
597 mbtitle = g_locale_from_utf8 (title, -1, NULL, NULL, NULL);
599 #ifdef WITHOUT_WM_CREATE
600 draw_impl->handle = CreateWindowEx (dwExStyle,
601 MAKEINTRESOURCE(klass),
613 CreateWindowEx (dwExStyle,
614 MAKEINTRESOURCE(klass),
623 if (GDK_WINDOW_HWND (window) != hwndNew)
625 g_warning("gdk_window_new: gdk_event_translate::WM_CREATE (%#x, %#x) HWND mismatch.",
626 (guint) GDK_WINDOW_HWND (window),
629 /* HB: IHMO due to a race condition the handle was increased by
630 * one, which causes much trouble. Because I can't find the
631 * real bug, try to workaround it ...
632 * To reproduce: compile with MSVC 5, DEBUG=1
635 gdk_win32_handle_table_remove (GDK_WINDOW_HWND (window));
636 GDK_WINDOW_HWND (window) = hwndNew;
637 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
639 /* the old behaviour, but with warning */
640 GDK_WINDOW_HWND (window) = hwndNew;
645 gdk_drawable_ref (window);
646 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
650 g_print ("... \"%s\" %dx%d@+%d+%d %#x = %#x\n"
651 "... locale %#x codepage %d\n",
653 width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
655 (guint) GDK_WINDOW_HWND (window),
656 (guint) impl->input_locale,
657 (guint) impl->charset_info.ciACP));
661 if (draw_impl->handle == NULL)
663 WIN32_API_FAILED ("CreateWindowEx");
664 g_object_unref ((GObject *) window);
668 #ifdef WITHOUT_WM_CREATE
669 gdk_drawable_ref (window);
670 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
673 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
674 (attributes->cursor) :
681 gdk_window_foreign_new (GdkNativeWindow anid)
684 GdkWindowObject *private;
685 GdkWindowObject *parent_private;
686 GdkWindowImplWin32 *impl;
687 GdkDrawableImplWin32 *draw_impl;
693 window = g_object_new (GDK_TYPE_WINDOW, NULL);
694 private = (GdkWindowObject *)window;
695 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
696 draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
697 draw_impl->wrapper = GDK_DRAWABLE (window);
698 parent = GetParent ((HWND)anid);
700 private->parent = gdk_win32_handle_table_lookup ((GdkNativeWindow) parent);
702 parent_private = (GdkWindowObject *)private->parent;
705 parent_private->children = g_list_prepend (parent_private->children, window);
707 draw_impl->handle = (HWND) anid;
708 GetClientRect ((HWND) anid, &rect);
710 point.y = rect.right;
711 ClientToScreen ((HWND) anid, &point);
712 if (parent != gdk_root_window)
713 ScreenToClient (parent, &point);
714 private->x = point.x;
715 private->y = point.y;
716 impl->width = rect.right - rect.left;
717 impl->height = rect.bottom - rect.top;
718 private->window_type = GDK_WINDOW_FOREIGN;
719 private->destroyed = FALSE;
720 private->mapped = IsWindowVisible ((HWND) anid);
721 private->depth = gdk_visual_get_system ()->depth;
723 gdk_drawable_ref (window);
724 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
730 _gdk_windowing_window_destroy (GdkWindow *window,
732 gboolean foreign_destroy)
734 GdkWindowObject *private = (GdkWindowObject *)window;
736 g_return_if_fail (GDK_IS_WINDOW (window));
738 GDK_NOTE (MISC, g_print ("_gdk_windowing_window_destroy %#x\n",
739 (guint) GDK_WINDOW_HWND (window)));
741 if (private->extension_events != 0)
742 gdk_input_window_destroy (window);
744 if (private->window_type == GDK_WINDOW_FOREIGN)
746 if (!foreign_destroy && (private->parent != NULL))
748 /* It's somebody else's window, but in our hierarchy,
749 * so reparent it to the root window, and then call
750 * DestroyWindow() on it.
752 gdk_window_hide (window);
753 gdk_window_reparent (window, NULL, 0, 0);
755 /* Is this too drastic? Many (most?) applications
756 * quit if any window receives WM_QUIT I think.
757 * OTOH, I don't think foreign windows are much
758 * used, so the question is maybe academic.
760 PostMessage (GDK_WINDOW_HWND (window), WM_QUIT, 0, 0);
763 else if (!recursing && !foreign_destroy)
764 DestroyWindow (GDK_WINDOW_HWND (window));
767 /* This function is called when the window really gone.
770 gdk_window_destroy_notify (GdkWindow *window)
772 g_return_if_fail (window != NULL);
773 g_return_if_fail (GDK_IS_WINDOW (window));
776 g_print ("gdk_window_destroy_notify: %#x %s\n",
777 (guint) GDK_WINDOW_HWND (window),
778 (GDK_WINDOW_DESTROYED (window) ? "(destroyed)" : "")));
780 if (!GDK_WINDOW_DESTROYED (window))
782 if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
783 g_warning ("window %#x unexpectedly destroyed",
784 (guint) GDK_WINDOW_HWND (window));
786 _gdk_window_destroy (window, TRUE);
789 gdk_win32_handle_table_remove (GDK_WINDOW_HWND (window));
790 gdk_drawable_unref (window);
794 gdk_window_show (GdkWindow *window)
796 GdkWindowObject *private;
798 g_return_if_fail (GDK_IS_WINDOW (window));
800 private = (GdkWindowObject*) window;
801 if (!private->destroyed)
803 GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
804 (guint) GDK_WINDOW_HWND (window)));
806 private->mapped = TRUE;
807 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP)
809 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNOACTIVATE);
810 SetWindowPos (GDK_WINDOW_HWND (window), HWND_TOPMOST, 0, 0, 0, 0,
811 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
813 /* Don't put on toolbar */
814 ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
819 if (GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE) & WS_EX_TRANSPARENT)
821 SetWindowPos(GDK_WINDOW_HWND (window), HWND_TOP, 0, 0, 0, 0,
822 SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOMOVE | SWP_NOSIZE);
826 GdkWindow *parent = private->parent;
828 ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNORMAL);
829 ShowWindow (GDK_WINDOW_HWND (window), SW_RESTORE);
830 if (parent == gdk_parent_root)
831 SetForegroundWindow (GDK_WINDOW_HWND (window));
832 BringWindowToTop (GDK_WINDOW_HWND (window));
834 ShowOwnedPopups (GDK_WINDOW_HWND (window), TRUE);
842 gdk_window_hide (GdkWindow *window)
844 GdkWindowObject *private;
846 g_return_if_fail (window != NULL);
848 private = (GdkWindowObject*) window;
849 if (!private->destroyed)
851 GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
852 (guint) GDK_WINDOW_HWND (window)));
854 private->mapped = FALSE;
855 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL)
856 ShowOwnedPopups (GDK_WINDOW_HWND (window), FALSE);
858 if (GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE) & WS_EX_TRANSPARENT)
860 SetWindowPos(GDK_WINDOW_HWND (window), HWND_BOTTOM, 0, 0, 0, 0,
861 SWP_HIDEWINDOW | SWP_NOREDRAW | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE);
865 ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
871 gdk_window_withdraw (GdkWindow *window)
873 GdkWindowObject *private;
875 g_return_if_fail (window != NULL);
877 private = (GdkWindowObject*) window;
878 if (!private->destroyed)
880 GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
881 (guint) GDK_WINDOW_HWND (window)));
883 gdk_window_hide (window); /* ??? */
888 gdk_window_move (GdkWindow *window,
892 GdkWindowObject *private = (GdkWindowObject *)window;
893 GdkWindowImplWin32 *impl;
895 g_return_if_fail (window != NULL);
896 g_return_if_fail (GDK_IS_WINDOW (window));
898 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
900 gdk_window_move_resize (window, x, y, impl->width, impl->height);
904 gdk_window_resize (GdkWindow *window,
908 GdkWindowObject *private = (GdkWindowObject*) window;
909 GdkWindowImplWin32 *impl;
912 g_return_if_fail (window != NULL);
913 g_return_if_fail (GDK_IS_WINDOW (window));
920 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
922 if (!private->destroyed)
924 GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
925 (guint) GDK_WINDOW_HWND (window),
928 if (GDK_WINDOW_TYPE (private) != GDK_WINDOW_CHILD)
937 ClientToScreen (GDK_WINDOW_HWND (window), &pt);
940 rect.right = pt.x + width;
941 rect.bottom = pt.y + height;
943 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
944 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
945 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
946 WIN32_API_FAILED ("AdjustWindowRectEx");
950 width = rect.right - rect.left;
951 height = rect.bottom - rect.top;
958 impl->height = height;
961 private->resize_count += 1;
963 GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
964 (guint) GDK_WINDOW_HWND (window),
965 width, height, x, y));
966 if (!MoveWindow (GDK_WINDOW_HWND (window), x, y, width, height, TRUE))
967 WIN32_API_FAILED ("MoveWindow");
972 gdk_window_move_resize (GdkWindow *window,
978 GdkWindowObject *private = (GdkWindowObject*) window;
979 GdkWindowImplWin32 *impl;
981 g_return_if_fail (window != NULL);
982 g_return_if_fail (GDK_IS_WINDOW (window));
989 impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
991 if (!private->destroyed)
997 GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
998 (guint) GDK_WINDOW_HWND (window),
999 width, height, x, y));
1001 if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
1002 _gdk_window_move_resize_child (window, x, y, width, height);
1007 rect.right = x + width;
1008 rect.bottom = y + height;
1010 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1011 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1012 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
1013 WIN32_API_FAILED ("AdjustWindowRectEx");
1015 GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%ldx%ld@+%ld+%ld)\n",
1016 (guint) GDK_WINDOW_HWND (window),
1017 rect.right - rect.left, rect.bottom - rect.top,
1018 rect.left, rect.top));
1019 if (!MoveWindow (GDK_WINDOW_HWND (window),
1020 rect.left, rect.top,
1021 rect.right - rect.left, rect.bottom - rect.top,
1023 WIN32_API_FAILED ("MoveWindow");
1029 gdk_window_reparent (GdkWindow *window,
1030 GdkWindow *new_parent,
1034 GdkWindowObject *window_private;
1035 GdkWindowObject *parent_private;
1036 GdkWindowObject *old_parent_private;
1037 GdkWindowImplWin32 *impl;
1039 g_return_if_fail (window != NULL);
1042 new_parent = gdk_parent_root;
1044 window_private = (GdkWindowObject*) window;
1045 old_parent_private = (GdkWindowObject *) window_private->parent;
1046 parent_private = (GdkWindowObject*) new_parent;
1047 impl = GDK_WINDOW_IMPL_WIN32 (window_private->impl);
1049 if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (new_parent))
1051 GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
1052 (guint) GDK_WINDOW_HWND (window),
1053 (guint) GDK_WINDOW_HWND (new_parent)));
1054 if (!SetParent (GDK_WINDOW_HWND (window),
1055 GDK_WINDOW_HWND (new_parent)))
1056 WIN32_API_FAILED ("SetParent");
1058 if (!MoveWindow (GDK_WINDOW_HWND (window),
1059 x, y, impl->width, impl->height, TRUE))
1060 WIN32_API_FAILED ("MoveWindow");
1063 window_private->parent = (GdkWindowObject *)new_parent;
1065 if (old_parent_private)
1066 old_parent_private->children =
1067 g_list_remove (old_parent_private->children, window);
1069 if ((old_parent_private &&
1070 (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
1071 (!old_parent_private && parent_private->guffaw_gravity))
1072 gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
1074 parent_private->children = g_list_prepend (parent_private->children, window);
1078 _gdk_windowing_window_clear_area (GdkWindow *window,
1084 GdkWindowImplWin32 *impl;
1086 g_return_if_fail (window != NULL);
1087 g_return_if_fail (GDK_IS_WINDOW (window));
1089 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1091 if (!GDK_WINDOW_DESTROYED (window))
1096 width = impl->width - x;
1098 height = impl->height - y;
1099 GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area: "
1100 "%#x %dx%d@+%d+%d\n",
1101 (guint) GDK_WINDOW_HWND (window),
1102 width, height, x, y));
1103 hdc = GetDC (GDK_WINDOW_HWND (window));
1104 IntersectClipRect (hdc, x, y, x + width + 1, y + height + 1);
1105 SendMessage (GDK_WINDOW_HWND (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
1106 ReleaseDC (GDK_WINDOW_HWND (window), hdc);
1111 _gdk_windowing_window_clear_area_e (GdkWindow *window,
1117 g_return_if_fail (window != NULL);
1118 g_return_if_fail (GDK_IS_WINDOW (window));
1120 if (!GDK_WINDOW_DESTROYED (window))
1124 GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area_e: "
1125 "%#x %dx%d@+%d+%d\n",
1126 (guint) GDK_WINDOW_HWND (window),
1127 width, height, x, y));
1130 rect.right = x + width + 1;
1132 rect.bottom = y + height + 1;
1133 if (!InvalidateRect (GDK_WINDOW_HWND (window), &rect, TRUE))
1134 WIN32_GDI_FAILED ("InvalidateRect");
1135 UpdateWindow (GDK_WINDOW_HWND (window));
1140 gdk_window_raise (GdkWindow *window)
1142 g_return_if_fail (window != NULL);
1143 g_return_if_fail (GDK_IS_WINDOW (window));
1145 if (!GDK_WINDOW_DESTROYED (window))
1147 GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n",
1148 (guint) GDK_WINDOW_HWND (window)));
1150 if (!BringWindowToTop (GDK_WINDOW_HWND (window)))
1151 WIN32_API_FAILED ("BringWindowToTop");
1156 gdk_window_lower (GdkWindow *window)
1158 g_return_if_fail (window != NULL);
1159 g_return_if_fail (GDK_IS_WINDOW (window));
1161 if (!GDK_WINDOW_DESTROYED (window))
1163 GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n",
1164 (guint) GDK_WINDOW_HWND (window)));
1166 if (!SetWindowPos (GDK_WINDOW_HWND (window), HWND_BOTTOM, 0, 0, 0, 0,
1167 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
1168 WIN32_API_FAILED ("SetWindowPos");
1173 gdk_window_set_hints (GdkWindow *window,
1182 GdkWindowImplWin32 *impl;
1183 WINDOWPLACEMENT size_hints;
1189 g_return_if_fail (window != NULL);
1190 g_return_if_fail (GDK_IS_WINDOW (window));
1192 if (GDK_WINDOW_DESTROYED (window))
1195 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1197 GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
1198 (guint) GDK_WINDOW_HWND (window),
1199 min_width, min_height, max_width, max_height,
1202 impl->hint_flags = flags;
1203 size_hints.length = sizeof (size_hints);
1207 if (flags & GDK_HINT_POS)
1209 if (!GetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1210 WIN32_API_FAILED ("GetWindowPlacement");
1213 GDK_NOTE (MISC, g_print ("...rcNormalPosition:"
1214 " (%ld,%ld)--(%ld,%ld)\n",
1215 size_hints.rcNormalPosition.left,
1216 size_hints.rcNormalPosition.top,
1217 size_hints.rcNormalPosition.right,
1218 size_hints.rcNormalPosition.bottom));
1219 /* What are the corresponding window coordinates for client
1220 * area coordinates x, y
1224 rect.right = rect.left + 200; /* dummy */
1225 rect.bottom = rect.top + 200;
1226 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1227 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1228 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1229 size_hints.flags = 0;
1230 size_hints.showCmd = SW_SHOWNA;
1232 /* Set the normal position hint to that location, with unchanged
1235 diff = size_hints.rcNormalPosition.left - rect.left;
1236 size_hints.rcNormalPosition.left = rect.left;
1237 size_hints.rcNormalPosition.right -= diff;
1238 diff = size_hints.rcNormalPosition.top - rect.top;
1239 size_hints.rcNormalPosition.top = rect.top;
1240 size_hints.rcNormalPosition.bottom -= diff;
1241 GDK_NOTE (MISC, g_print ("...setting: (%ld,%ld)--(%ld,%ld)\n",
1242 size_hints.rcNormalPosition.left,
1243 size_hints.rcNormalPosition.top,
1244 size_hints.rcNormalPosition.right,
1245 size_hints.rcNormalPosition.bottom));
1246 if (!SetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1247 WIN32_API_FAILED ("SetWindowPlacement");
1248 impl->hint_x = rect.left;
1249 impl->hint_y = rect.top;
1253 if (flags & GDK_HINT_MIN_SIZE)
1257 rect.right = min_width;
1258 rect.bottom = min_height;
1259 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1260 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1261 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1262 impl->hint_min_width = rect.right - rect.left;
1263 impl->hint_min_height = rect.bottom - rect.top;
1265 /* Also chek if he current size of the window is in bounds. */
1266 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1267 if (rect.right < min_width && rect.bottom < min_height)
1268 gdk_window_resize (window, min_width, min_height);
1269 else if (rect.right < min_width)
1270 gdk_window_resize (window, min_width, rect.bottom);
1271 else if (rect.bottom < min_height)
1272 gdk_window_resize (window, rect.right, min_height);
1275 if (flags & GDK_HINT_MAX_SIZE)
1279 rect.right = max_width;
1280 rect.bottom = max_height;
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 impl->hint_max_width = rect.right - rect.left;
1285 impl->hint_max_height = rect.bottom - rect.top;
1286 /* Again, check if the window is too large currently. */
1287 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1288 if (rect.right > max_width && rect.bottom > max_height)
1289 gdk_window_resize (window, max_width, max_height);
1290 else if (rect.right > max_width)
1291 gdk_window_resize (window, max_width, rect.bottom);
1292 else if (rect.bottom > max_height)
1293 gdk_window_resize (window, rect.right, max_height);
1299 gdk_window_set_geometry_hints (GdkWindow *window,
1300 GdkGeometry *geometry,
1301 GdkWindowHints geom_mask)
1303 GdkWindowImplWin32 *impl;
1304 WINDOWPLACEMENT size_hints;
1309 g_return_if_fail (window != NULL);
1310 g_return_if_fail (GDK_IS_WINDOW (window));
1312 if (GDK_WINDOW_DESTROYED (window))
1315 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1316 size_hints.length = sizeof (size_hints);
1318 impl->hint_flags = geom_mask;
1320 if (geom_mask & GDK_HINT_POS)
1323 if (geom_mask & GDK_HINT_MIN_SIZE)
1327 rect.right = geometry->min_width;
1328 rect.bottom = geometry->min_height;
1329 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1330 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1331 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1332 impl->hint_min_width = rect.right - rect.left;
1333 impl->hint_min_height = rect.bottom - rect.top;
1335 /* Also check if he current size of the window is in bounds */
1336 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1337 if (rect.right < geometry->min_width
1338 && rect.bottom < geometry->min_height)
1339 gdk_window_resize (window, geometry->min_width, geometry->min_height);
1340 else if (rect.right < geometry->min_width)
1341 gdk_window_resize (window, geometry->min_width, rect.bottom);
1342 else if (rect.bottom < geometry->min_height)
1343 gdk_window_resize (window, rect.right, geometry->min_height);
1346 if (geom_mask & GDK_HINT_MAX_SIZE)
1350 rect.right = geometry->max_width;
1351 rect.bottom = geometry->max_height;
1352 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1353 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1354 /* HB: dont' know why AdjustWindowRectEx is called here, ... */
1355 SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1356 impl->hint_max_width = rect.right - rect.left;
1357 impl->hint_max_height = rect.bottom - rect.top;
1358 /* ... but negative sizes are always wrong */
1359 if (impl->hint_max_width < 0) impl->hint_max_width = G_MAXSHORT;
1360 if (impl->hint_max_height < 0) impl->hint_max_height = G_MAXSHORT;
1362 /* Again, check if the window is too large currently. */
1363 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1364 if (rect.right > geometry->max_width
1365 && rect.bottom > geometry->max_height)
1366 gdk_window_resize (window, geometry->max_width, geometry->max_height);
1367 else if (rect.right > geometry->max_width)
1368 gdk_window_resize (window, geometry->max_width, rect.bottom);
1369 else if (rect.bottom > geometry->max_height)
1370 gdk_window_resize (window, rect.right, geometry->max_height);
1373 /* I don't know what to do when called with zero base_width and height. */
1374 if (geom_mask & GDK_HINT_BASE_SIZE
1375 && geometry->base_width > 0
1376 && geometry->base_height > 0)
1378 if (!GetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1379 WIN32_API_FAILED ("GetWindowPlacement");
1382 GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
1383 " rcNormalPosition: (%ld,%ld)--(%ld,%ld)\n",
1384 size_hints.rcNormalPosition.left,
1385 size_hints.rcNormalPosition.top,
1386 size_hints.rcNormalPosition.right,
1387 size_hints.rcNormalPosition.bottom));
1388 size_hints.rcNormalPosition.right =
1389 size_hints.rcNormalPosition.left + geometry->base_width;
1390 size_hints.rcNormalPosition.bottom =
1391 size_hints.rcNormalPosition.top + geometry->base_height;
1392 GDK_NOTE (MISC, g_print ("...setting: rcNormal: (%ld,%ld)--(%ld,%ld)\n",
1393 size_hints.rcNormalPosition.left,
1394 size_hints.rcNormalPosition.top,
1395 size_hints.rcNormalPosition.right,
1396 size_hints.rcNormalPosition.bottom));
1397 if (!SetWindowPlacement (GDK_WINDOW_HWND (window), &size_hints))
1398 WIN32_API_FAILED ("SetWindowPlacement");
1402 if (geom_mask & GDK_HINT_RESIZE_INC)
1407 if (geom_mask & GDK_HINT_ASPECT)
1414 gdk_window_set_title (GdkWindow *window,
1419 g_return_if_fail (window != NULL);
1420 g_return_if_fail (GDK_IS_WINDOW (window));
1421 g_return_if_fail (title != NULL);
1423 /* Empty window titles not allowed, so set it to just a period. */
1427 GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
1428 (guint) GDK_WINDOW_HWND (window), title));
1430 if (!GDK_WINDOW_DESTROYED (window))
1432 /* As the title is in UTF-8 we must translate it
1433 * to the system codepage.
1435 mbtitle = g_locale_from_utf8 (title, -1, NULL, NULL, NULL);
1436 if (!SetWindowText (GDK_WINDOW_HWND (window), mbtitle))
1437 WIN32_API_FAILED ("SetWindowText");
1444 gdk_window_set_role (GdkWindow *window,
1447 g_return_if_fail (window != NULL);
1448 g_return_if_fail (GDK_IS_WINDOW (window));
1450 GDK_NOTE (MISC, g_print ("gdk_window_set_role: %#x %s\n",
1451 (guint) GDK_WINDOW_HWND (window),
1452 (role ? role : "NULL")));
1457 gdk_window_set_transient_for (GdkWindow *window,
1460 g_return_if_fail (window != NULL);
1461 g_return_if_fail (GDK_IS_WINDOW (window));
1463 GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %#x %#x\n",
1464 (guint) GDK_WINDOW_HWND (window),
1465 (guint) GDK_WINDOW_HWND (parent)));
1470 gdk_window_set_background (GdkWindow *window,
1473 GdkWindowObject *private = (GdkWindowObject *)window;
1475 g_return_if_fail (window != NULL);
1476 g_return_if_fail (GDK_IS_WINDOW (window));
1478 GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
1479 (guint) GDK_WINDOW_HWND (window),
1480 gdk_win32_color_to_string (color)));
1482 private->bg_color = *color;
1484 if (private->bg_pixmap &&
1485 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1486 private->bg_pixmap != GDK_NO_BG)
1488 gdk_drawable_unref (private->bg_pixmap);
1489 private->bg_pixmap = NULL;
1494 gdk_window_set_back_pixmap (GdkWindow *window,
1496 gint parent_relative)
1498 GdkWindowObject *private = (GdkWindowObject *)window;
1500 g_return_if_fail (window != NULL);
1501 g_return_if_fail (GDK_IS_WINDOW (window));
1502 g_return_if_fail (pixmap == NULL || !parent_relative);
1504 if (private->bg_pixmap &&
1505 private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
1506 private->bg_pixmap != GDK_NO_BG)
1507 gdk_drawable_unref (private->bg_pixmap);
1509 if (parent_relative)
1511 private->bg_pixmap = GDK_PARENT_RELATIVE_BG;
1517 gdk_drawable_ref (pixmap);
1518 private->bg_pixmap = pixmap;
1522 private->bg_pixmap = GDK_NO_BG;
1528 gdk_window_set_cursor (GdkWindow *window,
1531 GdkWindowImplWin32 *impl;
1532 GdkCursorPrivate *cursor_private;
1536 g_return_if_fail (window != NULL);
1537 g_return_if_fail (GDK_IS_WINDOW (window));
1539 impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
1540 cursor_private = (GdkCursorPrivate*) cursor;
1542 if (!GDK_WINDOW_DESTROYED (window))
1547 hcursor = cursor_private->hcursor;
1549 GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
1550 (guint) GDK_WINDOW_HWND (window),
1552 if (impl->hcursor != NULL)
1554 GDK_NOTE (MISC, g_print ("...DestroyCursor (%#x)\n",
1555 (guint) impl->hcursor));
1557 DestroyCursor (impl->hcursor);
1558 impl->hcursor = NULL;
1560 if (hcursor != NULL)
1562 /* We must copy the cursor as it is OK to destroy the GdkCursor
1563 * while still in use for some window. See for instance
1564 * gimp_change_win_cursor() which calls
1565 * gdk_window_set_cursor (win, cursor), and immediately
1566 * afterwards gdk_cursor_destroy (cursor).
1568 impl->hcursor = CopyCursor (hcursor);
1569 GDK_NOTE (MISC, g_print ("...CopyCursor (%#x) = %#x\n",
1570 (guint) hcursor, (guint) impl->hcursor));
1573 if (ChildWindowFromPoint (GDK_WINDOW_HWND (window), pt) == GDK_WINDOW_HWND (window))
1574 SetCursor (impl->hcursor);
1580 gdk_window_get_geometry (GdkWindow *window,
1587 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1590 window = gdk_parent_root;
1592 if (!GDK_WINDOW_DESTROYED (window))
1596 if (!GetClientRect (GDK_WINDOW_HWND (window), &rect))
1597 WIN32_API_FAILED ("GetClientRect");
1604 *width = rect.right - rect.left;
1606 *height = rect.bottom - rect.top;
1608 *depth = gdk_drawable_get_visual (window)->depth;
1613 gdk_window_get_origin (GdkWindow *window,
1621 g_return_val_if_fail (window != NULL, 0);
1623 if (!GDK_WINDOW_DESTROYED (window))
1629 ClientToScreen (GDK_WINDOW_HWND (window), &pt);
1642 GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %#x: +%d+%d\n",
1643 (guint) GDK_WINDOW_HWND (window),
1649 gdk_window_get_deskrelative_origin (GdkWindow *window,
1653 return gdk_window_get_origin (window, x, y);
1657 gdk_window_get_root_origin (GdkWindow *window,
1661 GdkWindowObject *rover;
1664 g_return_if_fail (window != NULL);
1665 g_return_if_fail (GDK_IS_WINDOW (window));
1667 rover = (GdkWindowObject*) window;
1673 if (GDK_WINDOW_DESTROYED (window))
1676 while (rover->parent && ((GdkWindowObject*) rover->parent)->parent)
1677 rover = (GdkWindowObject *) rover->parent;
1678 if (rover->destroyed)
1683 ClientToScreen (GDK_WINDOW_HWND (rover), &pt);
1689 GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%ld+%ld\n",
1690 (guint) GDK_WINDOW_HWND (window),
1691 (guint) GDK_WINDOW_HWND (rover),
1696 gdk_window_get_pointer (GdkWindow *window,
1699 GdkModifierType *mask)
1701 GdkWindow *return_val;
1702 POINT pointc, point;
1705 g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1708 window = gdk_parent_root;
1711 GetCursorPos (&pointc);
1713 ScreenToClient (GDK_WINDOW_HWND (window), &point);
1720 hwnd = WindowFromPoint (point);
1722 ScreenToClient (hwnd, &point);
1725 hwndc = ChildWindowFromPoint (hwnd, point);
1726 ClientToScreen (hwnd, &point);
1727 ScreenToClient (hwndc, &point);
1728 } while (hwndc != hwnd && (hwnd = hwndc, 1)); /* Ouch! */
1730 return_val = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
1736 GetKeyboardState (kbd);
1738 if (kbd[VK_SHIFT] & 0x80)
1739 *mask |= GDK_SHIFT_MASK;
1740 if (kbd[VK_CAPITAL] & 0x80)
1741 *mask |= GDK_LOCK_MASK;
1742 if (kbd[VK_CONTROL] & 0x80)
1743 *mask |= GDK_CONTROL_MASK;
1744 if (kbd[VK_MENU] & 0x80)
1745 *mask |= GDK_MOD1_MASK;
1746 if (kbd[VK_LBUTTON] & 0x80)
1747 *mask |= GDK_BUTTON1_MASK;
1748 if (kbd[VK_MBUTTON] & 0x80)
1749 *mask |= GDK_BUTTON2_MASK;
1750 if (kbd[VK_RBUTTON] & 0x80)
1751 *mask |= GDK_BUTTON3_MASK;
1758 gdk_window_at_pointer (gint *win_x,
1762 POINT point, pointc;
1766 GetCursorPos (&pointc);
1768 hwnd = WindowFromPoint (point);
1772 window = gdk_parent_root;
1780 ScreenToClient (hwnd, &point);
1783 hwndc = ChildWindowFromPoint (hwnd, point);
1784 ClientToScreen (hwnd, &point);
1785 ScreenToClient (hwndc, &point);
1786 } while (hwndc != hwnd && (hwnd = hwndc, 1));
1788 window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
1790 if (window && (win_x || win_y))
1792 GetClientRect (hwnd, &rect);
1794 *win_x = point.x - rect.left;
1796 *win_y = point.y - rect.top;
1799 GDK_NOTE (MISC, g_print ("gdk_window_at_pointer: +%ld+%ld %#x%s\n",
1802 (window == NULL ? " NULL" : "")));
1808 gdk_window_get_events (GdkWindow *window)
1810 g_return_val_if_fail (window != NULL, 0);
1811 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
1813 if (GDK_WINDOW_DESTROYED (window))
1816 return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask;
1820 gdk_window_set_events (GdkWindow *window,
1821 GdkEventMask event_mask)
1823 g_return_if_fail (window != NULL);
1824 g_return_if_fail (GDK_IS_WINDOW (window));
1826 if (GDK_WINDOW_DESTROYED (window))
1829 GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask = event_mask;
1833 gdk_window_shape_combine_mask (GdkWindow *window,
1837 g_return_if_fail (window != NULL);
1838 g_return_if_fail (GDK_IS_WINDOW (window));
1842 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x none\n",
1843 (guint) GDK_WINDOW_HWND (window)));
1844 SetWindowRgn (GDK_WINDOW_HWND (window), NULL, TRUE);
1853 /* Convert mask bitmap to region */
1854 hrgn = BitmapToRegion (GDK_WINDOW_HWND (mask));
1856 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
1857 (guint) GDK_WINDOW_HWND (window),
1858 (guint) GDK_WINDOW_HWND (mask)));
1860 /* SetWindowRgn wants window (not client) coordinates */
1861 dwStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1862 dwExStyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1863 GetClientRect (GDK_WINDOW_HWND (window), &rect);
1864 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1865 OffsetRgn (hrgn, -rect.left, -rect.top);
1867 OffsetRgn (hrgn, x, y);
1869 /* If this is a top-level window, add the title bar to the region */
1870 if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_TOPLEVEL)
1872 CombineRgn (hrgn, hrgn,
1873 CreateRectRgn (0, 0, rect.right - rect.left, -rect.top),
1877 SetWindowRgn (GDK_WINDOW_HWND (window), hrgn, TRUE);
1882 gdk_window_set_override_redirect (GdkWindow *window,
1883 gboolean override_redirect)
1885 g_return_if_fail (window != NULL);
1886 g_return_if_fail (GDK_IS_WINDOW (window));
1888 g_warning ("gdk_window_set_override_redirect not implemented");
1892 gdk_window_set_icon (GdkWindow *window,
1893 GdkWindow *icon_window,
1897 g_return_if_fail (window != NULL);
1898 g_return_if_fail (GDK_IS_WINDOW (window));
1900 if (GDK_WINDOW_DESTROYED (window))
1903 /* Nothing to do, really. As we share window classes between windows
1904 * we can't have window-specific icons, sorry. Don't print any warning
1910 gdk_window_set_icon_name (GdkWindow *window,
1913 g_return_if_fail (window != NULL);
1914 g_return_if_fail (GDK_IS_WINDOW (window));
1916 if (GDK_WINDOW_DESTROYED (window))
1919 if (!SetWindowText (GDK_WINDOW_HWND (window), name))
1920 WIN32_API_FAILED ("SetWindowText");
1924 gdk_window_set_group (GdkWindow *window,
1927 g_return_if_fail (window != NULL);
1928 g_return_if_fail (GDK_IS_WINDOW (window));
1929 g_return_if_fail (leader != NULL);
1930 g_return_if_fail (GDK_IS_WINDOW (leader));
1932 if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (leader))
1935 g_warning ("gdk_window_set_group not implemented");
1939 gdk_window_set_decorations (GdkWindow *window,
1940 GdkWMDecoration decorations)
1942 LONG style, exstyle;
1944 g_return_if_fail (window != NULL);
1945 g_return_if_fail (GDK_IS_WINDOW (window));
1947 style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1948 exstyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1950 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
1951 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
1953 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
1955 if (decorations & GDK_DECOR_ALL)
1956 style |= (WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
1957 if (decorations & GDK_DECOR_BORDER)
1958 style |= (WS_BORDER);
1959 if (decorations & GDK_DECOR_RESIZEH)
1960 style |= (WS_THICKFRAME);
1961 if (decorations & GDK_DECOR_TITLE)
1962 style |= (WS_CAPTION);
1963 if (decorations & GDK_DECOR_MENU)
1964 style |= (WS_SYSMENU);
1965 if (decorations & GDK_DECOR_MINIMIZE)
1966 style |= (WS_MINIMIZEBOX);
1967 if (decorations & GDK_DECOR_MAXIMIZE)
1968 style |= (WS_MAXIMIZEBOX);
1970 SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
1974 gdk_window_set_functions (GdkWindow *window,
1975 GdkWMFunction functions)
1977 LONG style, exstyle;
1979 g_return_if_fail (window != NULL);
1980 g_return_if_fail (GDK_IS_WINDOW (window));
1982 style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
1983 exstyle = GetWindowLong (GDK_WINDOW_HWND (window), GWL_EXSTYLE);
1985 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
1986 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
1989 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
1991 if (functions & GDK_FUNC_ALL)
1992 style |= (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
1993 if (functions & GDK_FUNC_RESIZE)
1994 style |= (WS_THICKFRAME);
1995 if (functions & GDK_FUNC_MOVE)
1996 style |= (WS_THICKFRAME);
1997 if (functions & GDK_FUNC_MINIMIZE)
1998 style |= (WS_MINIMIZEBOX);
1999 if (functions & GDK_FUNC_MAXIMIZE)
2000 style |= (WS_MAXIMIZEBOX);
2002 SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
2006 * propagate the shapes from all child windows of a GDK window to the parent
2007 * window. Shamelessly ripped from Enlightenment's code
2013 QueryTree (HWND hwnd,
2023 child = GetWindow (hwnd, GW_CHILD);
2025 child = GetWindow (child, GW_HWNDNEXT);
2028 } while (child != NULL);
2032 *children = g_new (HWND, n);
2033 for (i = 0; i < n; i++)
2036 child = GetWindow (hwnd, GW_CHILD);
2038 child = GetWindow (child, GW_HWNDNEXT);
2039 *children[i] = child;
2045 gdk_propagate_shapes (HANDLE win,
2049 HRGN region, childRegion;
2053 SetRectEmpty (&emptyRect);
2054 region = CreateRectRgnIndirect (&emptyRect);
2056 GetWindowRgn (win, region);
2058 QueryTree (win, &list, &num);
2061 WINDOWPLACEMENT placement;
2063 placement.length = sizeof (WINDOWPLACEMENT);
2064 /* go through all child windows and combine regions */
2065 for (i = 0; i < num; i++)
2067 GetWindowPlacement (list[i], &placement);
2068 if (placement.showCmd == SW_SHOWNORMAL)
2070 childRegion = CreateRectRgnIndirect (&emptyRect);
2071 GetWindowRgn (list[i], childRegion);
2072 CombineRgn (region, region, childRegion, RGN_OR);
2073 DeleteObject (childRegion);
2076 SetWindowRgn (win, region, TRUE);
2079 DeleteObject (region);
2083 gdk_window_set_child_shapes (GdkWindow *window)
2085 g_return_if_fail (window != NULL);
2086 g_return_if_fail (GDK_IS_WINDOW (window));
2088 if (GDK_WINDOW_DESTROYED (window))
2091 gdk_propagate_shapes (GDK_WINDOW_HWND (window), FALSE);
2095 gdk_window_merge_child_shapes (GdkWindow *window)
2097 g_return_if_fail (window != NULL);
2098 g_return_if_fail (GDK_IS_WINDOW (window));
2100 if (GDK_WINDOW_DESTROYED (window))
2103 gdk_propagate_shapes (GDK_WINDOW_HWND (window), TRUE);
2106 /* Support for windows that can be guffaw-scrolled
2107 * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
2111 gdk_window_gravity_works (void)
2113 enum { UNKNOWN, NO, YES };
2114 static gint gravity_works = UNKNOWN;
2116 if (gravity_works == UNKNOWN)
2123 attr.window_type = GDK_WINDOW_TEMP;
2124 attr.wclass = GDK_INPUT_OUTPUT;
2129 attr.event_mask = 0;
2131 parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
2133 attr.window_type = GDK_WINDOW_CHILD;
2134 child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
2136 gdk_window_set_static_win_gravity (child, TRUE);
2138 gdk_window_resize (parent, 100, 110);
2139 gdk_window_move (parent, 0, -10);
2140 gdk_window_move_resize (parent, 0, 0, 100, 100);
2142 gdk_window_resize (parent, 100, 110);
2143 gdk_window_move (parent, 0, -10);
2144 gdk_window_move_resize (parent, 0, 0, 100, 100);
2146 gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
2148 gdk_window_destroy (parent);
2149 gdk_window_destroy (child);
2151 gravity_works = ((y == -20) ? YES : NO);
2154 return (gravity_works == YES);
2158 gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
2160 g_return_if_fail (window != NULL);
2162 GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
2166 gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
2168 g_return_if_fail (window != NULL);
2171 g_print ("gdk_window_set_static_win_gravity: Not implemented\n"));
2174 /*************************************************************
2175 * gdk_window_set_static_gravities:
2176 * Set the bit gravity of the given window to static,
2177 * and flag it so all children get static subwindow
2180 * window: window for which to set static gravity
2181 * use_static: Whether to turn static gravity on or off.
2183 * Does the XServer support static gravity?
2184 *************************************************************/
2187 gdk_window_set_static_gravities (GdkWindow *window,
2188 gboolean use_static)
2190 GdkWindowObject *private = (GdkWindowObject *)window;
2193 g_return_val_if_fail (window != NULL, FALSE);
2194 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2196 if (!use_static == !private->guffaw_gravity)
2199 if (use_static && !gdk_window_gravity_works ())
2202 private->guffaw_gravity = use_static;
2204 if (!GDK_WINDOW_DESTROYED (window))
2206 gdk_window_set_static_bit_gravity (window, use_static);
2208 tmp_list = private->children;
2211 gdk_window_set_static_win_gravity (window, use_static);
2213 tmp_list = tmp_list->next;