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 Library 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 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library 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-1999. 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/.
33 #include "gdkevents.h"
34 #include "gdkpixmap.h"
35 #include "gdkwindow.h"
36 #include "gdkprivate-win32.h"
37 #include "gdkinputprivate.h"
40 static gboolean gdk_window_gravity_works (void);
41 static void gdk_window_set_static_win_gravity (GdkWindow *window,
44 /* The Win API function AdjustWindowRect may return negative values
45 * resulting in obscured title bars. This helper function is coreccting it.
48 SafeAdjustWindowRectEx (RECT* lpRect,
53 if (!AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle))
55 WIN32_API_FAILED ("AdjustWindowRectEx");
60 lpRect->right -= lpRect->left;
65 lpRect->bottom -= lpRect->top;
72 gdk_win32_window_destroy (GdkDrawable *drawable)
74 if (!GDK_DRAWABLE_DESTROYED (drawable))
76 if (GDK_DRAWABLE_TYPE (drawable) == GDK_WINDOW_FOREIGN)
77 gdk_xid_table_remove (GDK_DRAWABLE_XID (drawable));
79 g_warning ("losing last reference to undestroyed window\n");
82 if (GDK_WINDOW_WIN32DATA (drawable)->bg_type == GDK_WIN32_BG_PIXMAP
83 && GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap != NULL)
84 gdk_drawable_unref (GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap);
86 g_free (GDK_DRAWABLE_WIN32DATA (drawable));
90 gdk_win32_window_alloc (void)
93 GdkWindowPrivate *private;
95 static GdkDrawableClass klass;
96 static gboolean initialized = FALSE;
102 klass = _gdk_win32_drawable_class;
103 klass.destroy = gdk_win32_window_destroy;
106 window = _gdk_window_alloc ();
107 private = (GdkWindowPrivate *) window;
109 private->drawable.klass = &klass;
110 private->drawable.klass_data = g_new (GdkWindowWin32Data, 1);
112 GDK_WINDOW_WIN32DATA (window)->event_mask = 0;
113 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
114 GDK_WINDOW_WIN32DATA (window)->xcursor = NULL;
115 GDK_WINDOW_WIN32DATA (window)->hint_flags = 0;
116 GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
118 GDK_WINDOW_WIN32DATA (window)->input_locale = GetKeyboardLayout (0);
119 TranslateCharsetInfo ((DWORD FAR *) GetACP (),
120 &GDK_WINDOW_WIN32DATA (window)->charset_info,
127 gdk_window_init (void)
129 GdkWindowPrivate *private;
134 SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
135 width = r.right - r.left;
136 height = r.bottom - r.top;
138 gdk_parent_root = gdk_win32_window_alloc ();
139 private = (GdkWindowPrivate *) gdk_parent_root;
141 GDK_DRAWABLE_WIN32DATA (gdk_parent_root)->xid = gdk_root_window;
142 private->drawable.window_type = GDK_WINDOW_ROOT;
143 private->drawable.width = width;
144 private->drawable.height = height;
146 gdk_xid_table_insert (&gdk_root_window, gdk_parent_root);
150 * is a wrapper function for RegisterWindowClassEx.
151 * It creates at least one unique class for every
152 * GdkWindowType. If support for single window-specific icons
153 * is ever needed (e.g Dialog specific), every such window should
157 RegisterGdkClass (GdkDrawableType wtype)
159 static ATOM klassTOPLEVEL = 0;
160 static ATOM klassDIALOG = 0;
161 static ATOM klassCHILD = 0;
162 static ATOM klassTEMP = 0;
163 static HICON hAppIcon = NULL;
164 static WNDCLASSEX wcl;
167 wcl.cbSize = sizeof(WNDCLASSEX);
168 wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
169 * on WM_SIZE and WM_MOVE. Flicker, Performance!
171 wcl.lpfnWndProc = gdk_WindowProc;
174 wcl.hInstance = gdk_ProgInstance;
176 /* initialize once! */
179 gchar sLoc [_MAX_PATH+1];
180 HINSTANCE hInst = GetModuleHandle(NULL);
182 if (0 != GetModuleFileName(hInst, sLoc, _MAX_PATH))
184 hAppIcon = ExtractIcon(hInst, sLoc, 0);
187 char *gdklibname = g_strdup_printf ("gdk-%s.dll", GDK_VERSION);
189 hAppIcon = ExtractIcon(hInst, gdklibname, 0);
194 hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
198 wcl.lpszMenuName = NULL;
201 /* initialize once per class */
202 #define ONCE_PER_CLASS() \
203 wcl.hIcon = CopyIcon (hAppIcon); \
204 wcl.hIconSm = CopyIcon (hAppIcon); \
205 wcl.hbrBackground = CreateSolidBrush( RGB(0,0,0)); \
206 wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
210 case GDK_WINDOW_TOPLEVEL:
211 if (0 == klassTOPLEVEL)
213 wcl.lpszClassName = "gdkWindowToplevel";
216 klassTOPLEVEL = RegisterClassEx(&wcl);
218 klass = klassTOPLEVEL;
220 case GDK_WINDOW_CHILD:
223 wcl.lpszClassName = "gdkWindowChild";
225 wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
227 klassCHILD = RegisterClassEx(&wcl);
231 case GDK_WINDOW_DIALOG:
232 if (0 == klassDIALOG)
234 wcl.lpszClassName = "gdkWindowDialog";
235 wcl.style |= CS_SAVEBITS;
237 klassDIALOG = RegisterClassEx(&wcl);
241 case GDK_WINDOW_TEMP:
244 wcl.lpszClassName = "gdkWindowTemp";
245 wcl.style |= CS_SAVEBITS;
247 klassTEMP = RegisterClassEx(&wcl);
251 case GDK_WINDOW_ROOT:
252 g_error ("cannot make windows of type GDK_WINDOW_ROOT");
254 case GDK_DRAWABLE_PIXMAP:
255 g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
261 WIN32_API_FAILED ("RegisterClassEx");
262 g_error ("That is a fatal error");
268 gdk_window_new (GdkWindow *parent,
269 GdkWindowAttr *attributes,
270 gint attributes_mask)
273 GdkWindowPrivate *private;
274 GdkWindowPrivate *parent_private;
279 DWORD dwStyle, dwExStyle;
289 g_return_val_if_fail (attributes != NULL, NULL);
292 parent = gdk_parent_root;
294 parent_private = (GdkWindowPrivate*) parent;
295 if (GDK_DRAWABLE_DESTROYED (parent))
298 xparent = GDK_DRAWABLE_XID (parent);
300 window = gdk_win32_window_alloc ();
301 private = (GdkWindowPrivate *)window;
303 private->parent = parent;
305 private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
306 private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
308 private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
309 private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
310 private->drawable.window_type = attributes->window_type;
311 GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
313 if (attributes_mask & GDK_WA_VISUAL)
314 visual = attributes->visual;
316 visual = gdk_visual_get_system ();
317 xvisual = ((GdkVisualPrivate*) visual)->xvisual;
319 if (attributes_mask & GDK_WA_TITLE)
320 title = attributes->title;
322 title = g_get_prgname ();
324 title = "GDK client window";
326 GDK_WINDOW_WIN32DATA (window)->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
328 if (parent_private && parent_private->guffaw_gravity)
333 if (attributes->wclass == GDK_INPUT_OUTPUT)
336 if (attributes_mask & GDK_WA_COLORMAP)
337 private->drawable.colormap = attributes->colormap;
339 private->drawable.colormap = gdk_colormap_get_system ();
343 dwExStyle = WS_EX_TRANSPARENT;
344 private->drawable.colormap = NULL;
345 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_TRANSPARENT;
346 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
349 if (attributes_mask & GDK_WA_X)
354 if (attributes_mask & GDK_WA_Y)
356 else if (attributes_mask & GDK_WA_X)
357 y = 100; /* ??? We must put it somewhere... */
359 y = 500; /* x is CW_USEDEFAULT, y doesn't matter then */
362 parent_private->children = g_list_prepend (parent_private->children, window);
364 switch (private->drawable.window_type)
366 case GDK_WINDOW_TOPLEVEL:
367 dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
368 xparent = gdk_root_window;
370 case GDK_WINDOW_CHILD:
371 dwStyle = WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
373 case GDK_WINDOW_DIALOG:
374 dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
376 dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
378 xparent = gdk_root_window;
380 case GDK_WINDOW_TEMP:
381 dwStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
382 dwExStyle |= WS_EX_TOOLWINDOW;
384 case GDK_WINDOW_ROOT:
385 g_error ("cannot make windows of type GDK_WINDOW_ROOT");
387 case GDK_DRAWABLE_PIXMAP:
388 g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
392 klass = RegisterGdkClass (private->drawable.window_type);
394 if (private->drawable.window_type != GDK_WINDOW_CHILD)
396 if (x == CW_USEDEFAULT)
407 rect.right = rect.left + private->drawable.width;
408 rect.bottom = rect.top + private->drawable.height;
410 SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
412 if (x != CW_USEDEFAULT)
417 width = rect.right - rect.left;
418 height = rect.bottom - rect.top;
422 width = private->drawable.width;
423 height = private->drawable.height;
426 titlelen = strlen (title);
427 wctitle = g_new (wchar_t, titlelen + 1);
428 mbtitle = g_new (char, 3*titlelen + 1);
429 wlen = gdk_nmbstowchar_ts (wctitle, title, titlelen, titlelen);
431 WideCharToMultiByte (GetACP (), 0, wctitle, -1,
432 mbtitle, 3*titlelen, NULL, NULL);
434 GDK_DRAWABLE_WIN32DATA (window)->xid =
435 CreateWindowEx (dwExStyle,
436 MAKEINTRESOURCE(klass),
447 g_print ("gdk_window_new: %s %s %dx%d@+%d+%d %#x = %#x\n"
448 "...locale %#x codepage %d\n",
449 (private->drawable.window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
450 (private->drawable.window_type == GDK_WINDOW_CHILD ? "CHILD" :
451 (private->drawable.window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
452 (private->drawable.window_type == GDK_WINDOW_TEMP ? "TEMP" :
455 width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
457 GDK_DRAWABLE_XID (window),
458 GDK_WINDOW_WIN32DATA (window)->input_locale,
459 GDK_WINDOW_WIN32DATA (window)->charset_info.ciACP));
464 if (GDK_DRAWABLE_XID (window) == NULL)
466 WIN32_API_FAILED ("CreateWindowEx");
467 g_free (GDK_DRAWABLE_WIN32DATA (window));
472 gdk_drawable_ref (window);
473 gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
475 if (private->drawable.colormap)
476 gdk_colormap_ref (private->drawable.colormap);
478 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
479 (attributes->cursor) :
486 gdk_window_foreign_new (guint32 anid)
489 GdkWindowPrivate *private;
490 GdkWindowPrivate *parent_private;
495 window = gdk_win32_window_alloc ();
496 private = (GdkWindowPrivate *)window;
498 parent = GetParent ((HWND) anid);
499 private->parent = gdk_xid_table_lookup (parent);
501 parent_private = (GdkWindowPrivate *)private->parent;
504 parent_private->children = g_list_prepend (parent_private->children, window);
506 GDK_DRAWABLE_WIN32DATA (window)->xid = (HWND) anid;
507 GetClientRect ((HWND) anid, &rect);
509 point.y = rect.right;
510 ClientToScreen ((HWND) anid, &point);
511 if (parent != GetDesktopWindow ())
512 ScreenToClient (parent, &point);
513 private->x = point.x;
514 private->y = point.y;
515 private->drawable.width = rect.right - rect.left;
516 private->drawable.height = rect.bottom - rect.top;
517 private->drawable.window_type = GDK_WINDOW_FOREIGN;
518 private->drawable.destroyed = FALSE;
519 private->mapped = IsWindowVisible (GDK_DRAWABLE_XID (window));
521 private->drawable.colormap = NULL;
523 gdk_drawable_ref (window);
524 gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
529 /* Call this function when you want a window and all its children to
530 * disappear. When xdestroy is true, a request to destroy the window
531 * is sent out. When it is false, it is assumed that the window has
532 * been or will be destroyed by destroying some ancestor of this
536 gdk_window_internal_destroy (GdkWindow *window,
538 gboolean our_destroy)
540 GdkWindowPrivate *private;
541 GdkWindowPrivate *temp_private;
542 GdkWindow *temp_window;
546 g_return_if_fail (window != NULL);
548 private = (GdkWindowPrivate *) window;
550 GDK_NOTE (MISC, g_print ("gdk_window_internal_destroy %#x\n",
551 GDK_DRAWABLE_XID (window)));
553 switch (GDK_DRAWABLE_TYPE (window))
555 case GDK_WINDOW_TOPLEVEL:
556 case GDK_WINDOW_CHILD:
557 case GDK_WINDOW_DIALOG:
558 case GDK_WINDOW_TEMP:
559 case GDK_WINDOW_FOREIGN:
560 if (!private->drawable.destroyed)
564 GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
565 if (parent_private->children)
566 parent_private->children = g_list_remove (parent_private->children, window);
569 if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
571 children = tmp = private->children;
572 private->children = NULL;
576 temp_window = tmp->data;
579 temp_private = (GdkWindowPrivate*) temp_window;
581 gdk_window_internal_destroy (temp_window, FALSE,
585 g_list_free (children);
588 if (private->extension_events != 0)
589 gdk_input_window_destroy (window);
591 if (private->filters)
593 tmp = private->filters;
601 g_list_free (private->filters);
602 private->filters = NULL;
605 if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
607 if (our_destroy && (private->parent != NULL))
609 /* It's somebody elses window, but in our hierarchy,
610 * so reparent it to the root window, and then send
611 * it a delete event, as if we were a WM
613 gdk_window_hide (window);
614 gdk_window_reparent (window, NULL, 0, 0);
616 /* Is this too drastic? Many (most?) applications
617 * quit if any window receives WM_QUIT I think.
618 * OTOH, I don't think foreign windows are much
619 * used, so the question is maybe academic.
621 PostMessage (GDK_DRAWABLE_XID (window), WM_QUIT, 0, 0);
625 DestroyWindow (GDK_DRAWABLE_XID (window));
627 if (private->drawable.colormap)
628 gdk_colormap_unref (private->drawable.colormap);
630 private->mapped = FALSE;
631 private->drawable.destroyed = TRUE;
635 case GDK_WINDOW_ROOT:
636 g_error ("attempted to destroy root window");
639 case GDK_DRAWABLE_PIXMAP:
640 g_error ("called gdk_window_destroy on a pixmap (use gdk_drawable_unref)");
645 /* Like internal_destroy, but also destroys the reference created by
649 gdk_window_destroy (GdkWindow *window)
651 gdk_window_internal_destroy (window, TRUE, TRUE);
652 gdk_drawable_unref (window);
655 /* This function is called when the window really gone. */
658 gdk_window_destroy_notify (GdkWindow *window)
660 g_return_if_fail (window != NULL);
663 g_print ("gdk_window_destroy_notify: %#x %s\n",
664 GDK_DRAWABLE_XID (window),
665 (GDK_DRAWABLE_DESTROYED (window) ? "yes" : "no")));
667 if (!GDK_DRAWABLE_DESTROYED (window))
669 if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
670 g_warning ("window %#x unexpectedly destroyed",
671 GDK_DRAWABLE_XID (window));
673 gdk_window_internal_destroy (window, FALSE, FALSE);
676 gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
677 gdk_drawable_unref (window);
681 gdk_window_show (GdkWindow *window)
683 g_return_if_fail (window != NULL);
685 if (!GDK_DRAWABLE_DESTROYED (window))
687 GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
688 GDK_DRAWABLE_XID (window)));
690 ((GdkWindowPrivate *) window)->mapped = TRUE;
691 if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TEMP)
693 ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNOACTIVATE);
694 SetWindowPos (GDK_DRAWABLE_XID (window), HWND_TOPMOST, 0, 0, 0, 0,
695 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
697 /* Don't put on toolbar */
698 ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
703 ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNORMAL);
704 ShowWindow (GDK_DRAWABLE_XID (window), SW_RESTORE);
705 SetForegroundWindow (GDK_DRAWABLE_XID (window));
706 BringWindowToTop (GDK_DRAWABLE_XID (window));
708 ShowOwnedPopups (GDK_DRAWABLE_XID (window), TRUE);
715 gdk_window_hide (GdkWindow *window)
717 g_return_if_fail (window != NULL);
719 if (!GDK_DRAWABLE_DESTROYED (window))
721 GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
722 GDK_DRAWABLE_XID (window)));
724 ((GdkWindowPrivate *) window)->mapped = FALSE;
725 if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
726 ShowOwnedPopups (GDK_DRAWABLE_XID (window), FALSE);
728 ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
730 ShowWindow (GDK_DRAWABLE_XID (window), SW_MINIMIZE);
732 CloseWindow (GDK_DRAWABLE_XID (window));
738 gdk_window_withdraw (GdkWindow *window)
740 g_return_if_fail (window != NULL);
742 if (!GDK_DRAWABLE_DESTROYED (window))
744 GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
745 GDK_DRAWABLE_XID (window)));
747 gdk_window_hide (window); /* XXX */
752 gdk_window_move (GdkWindow *window,
756 GdkWindowPrivate *private;
758 g_return_if_fail (window != NULL);
760 if (!GDK_DRAWABLE_DESTROYED (window))
764 GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
765 GDK_DRAWABLE_XID (window), x, y));
767 private = (GdkWindowPrivate *) window;
768 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
770 if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
778 ClientToScreen (GDK_DRAWABLE_XID (window), &ptTL);
783 ptBR.y = rect.bottom;
784 ClientToScreen (GDK_DRAWABLE_XID (window), &ptBR);
785 rect.right = x + ptBR.x - ptTL.x;
786 rect.bottom = y + ptBR.y - ptTL.y;
788 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
789 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
790 SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
800 GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
801 GDK_DRAWABLE_XID (window),
802 rect.right - rect.left, rect.bottom - rect.top,
804 if (!MoveWindow (GDK_DRAWABLE_XID (window),
805 x, y, rect.right - rect.left, rect.bottom - rect.top,
807 WIN32_API_FAILED ("MoveWindow");
812 gdk_window_resize (GdkWindow *window,
816 GdkWindowPrivate *private;
818 g_return_if_fail (window != NULL);
820 if ((gint16) width < 1)
822 if ((gint16) height < 1)
825 private = (GdkWindowPrivate*) window;
827 if (!private->drawable.destroyed &&
828 ((private->resize_count > 0) ||
829 (private->drawable.width != (guint16) width) ||
830 (private->drawable.height != (guint16) height)))
834 GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
835 GDK_DRAWABLE_XID (window), width, height));
837 if (private->drawable.window_type != GDK_WINDOW_CHILD)
846 ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
849 rect.right = pt.x + width;
850 rect.bottom = pt.y + height;
852 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
853 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
854 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
855 WIN32_API_FAILED ("AdjustWindowRectEx");
859 width = rect.right - rect.left;
860 height = rect.bottom - rect.top;
866 private->drawable.width = width;
867 private->drawable.height = height;
870 private->resize_count += 1;
873 g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
874 GDK_DRAWABLE_XID (window), width, height, x, y));
875 if (!MoveWindow (GDK_DRAWABLE_XID (window),
878 WIN32_API_FAILED ("MoveWindow");
883 gdk_window_move_resize (GdkWindow *window,
889 GdkWindowPrivate *private;
891 g_return_if_fail (window != NULL);
893 if ((gint16) width < 1)
895 if ((gint16) height < 1)
898 if (!GDK_DRAWABLE_DESTROYED (window))
904 GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
905 GDK_DRAWABLE_XID (window), width, height, x, y));
907 private = (GdkWindowPrivate*) window;
910 rect.right = x + width;
911 rect.bottom = y + height;
913 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
914 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
915 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
916 WIN32_API_FAILED ("AdjustWindowRectEx");
918 if (private->drawable.window_type == GDK_WINDOW_CHILD)
922 private->drawable.width = width;
923 private->drawable.height = height;
925 GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
926 GDK_DRAWABLE_XID (window),
927 rect.right - rect.left, rect.bottom - rect.top,
928 rect.left, rect.top));
929 if (!MoveWindow (GDK_DRAWABLE_XID (window),
931 rect.right - rect.left, rect.bottom - rect.top,
933 WIN32_API_FAILED ("MoveWindow");
935 if (private->guffaw_gravity)
937 GList *tmp_list = private->children;
940 GdkWindowPrivate *child_private = tmp_list->data;
942 child_private->x -= x - private->x;
943 child_private->y -= y - private->y;
945 tmp_list = tmp_list->next;
953 gdk_window_reparent (GdkWindow *window,
954 GdkWindow *new_parent,
958 GdkWindowPrivate *window_private;
959 GdkWindowPrivate *parent_private;
960 GdkWindowPrivate *old_parent_private;
962 g_return_if_fail (window != NULL);
965 new_parent = gdk_parent_root;
967 window_private = (GdkWindowPrivate*) window;
968 old_parent_private = (GdkWindowPrivate *) window_private->parent;
969 parent_private = (GdkWindowPrivate*) new_parent;
971 if (!GDK_DRAWABLE_DESTROYED (window)
972 && !GDK_DRAWABLE_DESTROYED (new_parent))
974 GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
975 GDK_DRAWABLE_XID (window),
976 GDK_DRAWABLE_XID (new_parent)));
977 if (!SetParent (GDK_DRAWABLE_XID (window),
978 GDK_DRAWABLE_XID (new_parent)))
979 WIN32_API_FAILED ("SetParent");
981 if (!MoveWindow (GDK_DRAWABLE_XID (window),
983 window_private->drawable.width,
984 window_private->drawable.height,
986 WIN32_API_FAILED ("MoveWindow");
989 window_private->parent = new_parent;
991 if (old_parent_private)
992 old_parent_private->children =
993 g_list_remove (old_parent_private->children, window);
995 if ((old_parent_private &&
996 (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
997 (!old_parent_private && parent_private->guffaw_gravity))
998 gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
1000 parent_private->children = g_list_prepend (parent_private->children, window);
1004 gdk_window_clear (GdkWindow *window)
1006 g_return_if_fail (window != NULL);
1007 g_return_if_fail (GDK_IS_WINDOW (window));
1009 if (!GDK_DRAWABLE_DESTROYED (window))
1010 gdk_window_clear_area (window, 0, 0, 0, 0);
1015 gdk_window_clear_area (GdkWindow *window,
1021 g_return_if_fail (window != NULL);
1022 g_return_if_fail (GDK_IS_WINDOW (window));
1024 if (!GDK_DRAWABLE_DESTROYED (window))
1029 width = ((GdkDrawablePrivate *) window)->width - x;
1031 height = ((GdkDrawablePrivate *) window)->height - y;
1032 GDK_NOTE (MISC, g_print ("gdk_window_clear_area: %#x %dx%d@+%d+%d\n",
1033 GDK_DRAWABLE_XID (window), width, height, x, y));
1034 hdc = GetDC (GDK_DRAWABLE_XID (window));
1035 IntersectClipRect (hdc, x, y, x + width, y + height);
1036 SendMessage (GDK_DRAWABLE_XID (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
1037 ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
1042 gdk_window_clear_area_e (GdkWindow *window,
1048 g_return_if_fail (window != NULL);
1049 g_return_if_fail (GDK_IS_WINDOW (window));
1051 if (!GDK_DRAWABLE_DESTROYED (window))
1055 GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
1056 GDK_DRAWABLE_XID (window), width, height, x, y));
1059 rect.right = x + width;
1061 rect.bottom = y + height;
1062 if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
1063 WIN32_GDI_FAILED ("InvalidateRect");
1064 UpdateWindow (GDK_DRAWABLE_XID (window));
1069 gdk_window_raise (GdkWindow *window)
1071 g_return_if_fail (window != NULL);
1072 g_return_if_fail (GDK_IS_WINDOW (window));
1074 if (!GDK_DRAWABLE_DESTROYED (window))
1076 GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n",
1077 GDK_DRAWABLE_XID (window)));
1079 if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
1080 WIN32_API_FAILED ("BringWindowToTop");
1085 gdk_window_lower (GdkWindow *window)
1087 g_return_if_fail (window != NULL);
1088 g_return_if_fail (GDK_IS_WINDOW (window));
1090 if (!GDK_DRAWABLE_DESTROYED (window))
1092 GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n",
1093 GDK_DRAWABLE_XID (window)));
1095 if (!SetWindowPos (GDK_DRAWABLE_XID (window), HWND_BOTTOM, 0, 0, 0, 0,
1096 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
1097 WIN32_API_FAILED ("SetWindowPos");
1102 gdk_window_set_hints (GdkWindow *window,
1111 WINDOWPLACEMENT size_hints;
1117 g_return_if_fail (window != NULL);
1118 g_return_if_fail (GDK_IS_WINDOW (window));
1120 if (GDK_DRAWABLE_DESTROYED (window))
1123 GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
1124 GDK_DRAWABLE_XID (window),
1125 min_width, min_height, max_width, max_height,
1128 GDK_WINDOW_WIN32DATA (window)->hint_flags = flags;
1129 size_hints.length = sizeof (size_hints);
1133 if (flags & GDK_HINT_POS)
1134 if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1135 WIN32_API_FAILED ("GetWindowPlacement");
1138 GDK_NOTE (MISC, g_print ("...rcNormalPosition:"
1139 " (%d,%d)--(%d,%d)\n",
1140 size_hints.rcNormalPosition.left,
1141 size_hints.rcNormalPosition.top,
1142 size_hints.rcNormalPosition.right,
1143 size_hints.rcNormalPosition.bottom));
1144 /* What are the corresponding window coordinates for client
1145 * area coordinates x, y
1149 rect.right = rect.left + 200; /* dummy */
1150 rect.bottom = rect.top + 200;
1151 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1152 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1153 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1154 size_hints.flags = 0;
1155 size_hints.showCmd = SW_SHOWNA;
1157 /* Set the normal position hint to that location, with unchanged
1160 diff = size_hints.rcNormalPosition.left - rect.left;
1161 size_hints.rcNormalPosition.left = rect.left;
1162 size_hints.rcNormalPosition.right -= diff;
1163 diff = size_hints.rcNormalPosition.top - rect.top;
1164 size_hints.rcNormalPosition.top = rect.top;
1165 size_hints.rcNormalPosition.bottom -= diff;
1166 GDK_NOTE (MISC, g_print ("...setting: (%d,%d)--(%d,%d)\n",
1167 size_hints.rcNormalPosition.left,
1168 size_hints.rcNormalPosition.top,
1169 size_hints.rcNormalPosition.right,
1170 size_hints.rcNormalPosition.bottom));
1171 if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1172 WIN32_API_FAILED ("SetWindowPlacement");
1173 GDK_WINDOW_WIN32DATA (window)->hint_x = rect.left;
1174 GDK_WINDOW_WIN32DATA (window)->hint_y = rect.top;
1177 if (flags & GDK_HINT_MIN_SIZE)
1181 rect.right = min_width;
1182 rect.bottom = min_height;
1183 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1184 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1185 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1186 GDK_WINDOW_WIN32DATA (window)->hint_min_width =
1187 rect.right - rect.left;
1188 GDK_WINDOW_WIN32DATA (window)->hint_min_height =
1189 rect.bottom - rect.top;
1191 /* Also chek if he current size of the window is in bounds. */
1192 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1193 if (rect.right < min_width && rect.bottom < min_height)
1194 gdk_window_resize (window, min_width, min_height);
1195 else if (rect.right < min_width)
1196 gdk_window_resize (window, min_width, rect.bottom);
1197 else if (rect.bottom < min_height)
1198 gdk_window_resize (window, rect.right, min_height);
1201 if (flags & GDK_HINT_MAX_SIZE)
1205 rect.right = max_width;
1206 rect.bottom = max_height;
1207 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1208 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1209 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1210 GDK_WINDOW_WIN32DATA (window)->hint_max_width =
1211 rect.right - rect.left;
1212 GDK_WINDOW_WIN32DATA (window)->hint_max_height =
1213 rect.bottom - rect.top;
1214 /* Again, check if the window is too large currently. */
1215 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1216 if (rect.right > max_width && rect.bottom > max_height)
1217 gdk_window_resize (window, max_width, max_height);
1218 else if (rect.right > max_width)
1219 gdk_window_resize (window, max_width, rect.bottom);
1220 else if (rect.bottom > max_height)
1221 gdk_window_resize (window, rect.right, max_height);
1227 gdk_window_set_geometry_hints (GdkWindow *window,
1228 GdkGeometry *geometry,
1229 GdkWindowHints geom_mask)
1231 WINDOWPLACEMENT size_hints;
1237 g_return_if_fail (window != NULL);
1238 g_return_if_fail (GDK_IS_WINDOW (window));
1240 if (GDK_DRAWABLE_DESTROYED (window))
1243 size_hints.length = sizeof (size_hints);
1245 GDK_WINDOW_WIN32DATA (window)->hint_flags = geom_mask;
1247 if (geom_mask & GDK_HINT_POS)
1250 if (geom_mask & GDK_HINT_MIN_SIZE)
1254 rect.right = geometry->min_width;
1255 rect.bottom = geometry->min_height;
1256 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1257 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1258 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1259 GDK_WINDOW_WIN32DATA (window)->hint_min_width = rect.right - rect.left;
1260 GDK_WINDOW_WIN32DATA (window)->hint_min_height = rect.bottom - rect.top;
1262 /* Also check if he current size of the window is in bounds */
1263 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1264 if (rect.right < geometry->min_width
1265 && rect.bottom < geometry->min_height)
1266 gdk_window_resize (window, geometry->min_width, geometry->min_height);
1267 else if (rect.right < geometry->min_width)
1268 gdk_window_resize (window, geometry->min_width, rect.bottom);
1269 else if (rect.bottom < geometry->min_height)
1270 gdk_window_resize (window, rect.right, geometry->min_height);
1273 if (geom_mask & GDK_HINT_MAX_SIZE)
1277 rect.right = geometry->max_width;
1278 rect.bottom = geometry->max_height;
1279 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1280 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1281 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1282 GDK_WINDOW_WIN32DATA (window)->hint_max_width = rect.right - rect.left;
1283 GDK_WINDOW_WIN32DATA (window)->hint_max_height = rect.bottom - rect.top;
1285 /* Again, check if the window is too large currently. */
1286 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1287 if (rect.right > geometry->max_width
1288 && rect.bottom > geometry->max_height)
1289 gdk_window_resize (window, geometry->max_width, geometry->max_height);
1290 else if (rect.right > geometry->max_width)
1291 gdk_window_resize (window, geometry->max_width, rect.bottom);
1292 else if (rect.bottom > geometry->max_height)
1293 gdk_window_resize (window, rect.right, geometry->max_height);
1296 /* I don't know what to do when called with zero base_width and height. */
1297 if (geom_mask & GDK_HINT_BASE_SIZE
1298 && geometry->base_width > 0
1299 && geometry->base_height > 0)
1300 if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1301 WIN32_API_FAILED ("GetWindowPlacement");
1304 GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
1305 " rcNormalPosition: (%d,%d)--(%d,%d)\n",
1306 size_hints.rcNormalPosition.left,
1307 size_hints.rcNormalPosition.top,
1308 size_hints.rcNormalPosition.right,
1309 size_hints.rcNormalPosition.bottom));
1310 size_hints.rcNormalPosition.right =
1311 size_hints.rcNormalPosition.left + geometry->base_width;
1312 size_hints.rcNormalPosition.bottom =
1313 size_hints.rcNormalPosition.top + geometry->base_height;
1314 GDK_NOTE (MISC, g_print ("...setting: rcNormal: (%d,%d)--(%d,%d)\n",
1315 size_hints.rcNormalPosition.left,
1316 size_hints.rcNormalPosition.top,
1317 size_hints.rcNormalPosition.right,
1318 size_hints.rcNormalPosition.bottom));
1319 if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1320 WIN32_API_FAILED ("SetWindowPlacement");
1323 if (geom_mask & GDK_HINT_RESIZE_INC)
1328 if (geom_mask & GDK_HINT_ASPECT)
1335 gdk_window_set_title (GdkWindow *window,
1343 g_return_if_fail (window != NULL);
1344 g_return_if_fail (GDK_IS_WINDOW (window));
1346 GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
1347 GDK_DRAWABLE_XID (window), title));
1348 if (!GDK_DRAWABLE_DESTROYED (window))
1350 /* As the title is in UTF-8 we must translate it
1351 * to the system codepage.
1353 titlelen = strlen (title);
1354 wcstr = g_new (wchar_t, titlelen + 1);
1355 mbstr = g_new (char, 3*titlelen + 1);
1356 wlen = gdk_nmbstowchar_ts (wcstr, title, titlelen, titlelen);
1358 WideCharToMultiByte (GetACP (), 0, wcstr, -1,
1359 mbstr, 3*titlelen, NULL, NULL);
1361 if (!SetWindowText (GDK_DRAWABLE_XID (window), mbstr))
1362 WIN32_API_FAILED ("SetWindowText");
1370 gdk_window_set_role (GdkWindow *window,
1373 g_return_if_fail (window != NULL);
1374 g_return_if_fail (GDK_IS_WINDOW (window));
1376 GDK_NOTE (MISC, g_print ("gdk_window_set_role: %#x %s\n",
1377 GDK_DRAWABLE_XID (window), (role ? role : "NULL")));
1382 gdk_window_set_transient_for (GdkWindow *window,
1385 g_return_if_fail (window != NULL);
1386 g_return_if_fail (GDK_IS_WINDOW (window));
1388 GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %#x %#x\n",
1389 GDK_DRAWABLE_XID (window),
1390 GDK_DRAWABLE_XID (parent)));
1395 gdk_window_set_background (GdkWindow *window,
1398 g_return_if_fail (window != NULL);
1399 g_return_if_fail (GDK_IS_WINDOW (window));
1401 if (!GDK_DRAWABLE_DESTROYED (window))
1403 GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
1404 GDK_DRAWABLE_XID (window),
1405 gdk_color_to_string (color)));
1407 if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
1409 if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
1411 gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
1412 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
1414 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
1416 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXEL;
1417 GDK_WINDOW_WIN32DATA (window)->bg_pixel = color->pixel;
1422 gdk_window_set_back_pixmap (GdkWindow *window,
1424 gint parent_relative)
1426 g_return_if_fail (window != NULL);
1427 g_return_if_fail (GDK_IS_WINDOW (window));
1429 if (!GDK_DRAWABLE_DESTROYED (window))
1431 if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
1433 if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
1435 gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
1436 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
1438 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
1440 if (parent_relative)
1442 GDK_WINDOW_WIN32DATA (window)->bg_type =
1443 GDK_WIN32_BG_PARENT_RELATIVE;
1451 /* We must cache the pixmap in the GdkWindowWin32Data and
1452 * paint it each time we get WM_ERASEBKGND
1454 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXMAP;
1455 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = pixmap;
1456 gdk_drawable_ref (pixmap);
1462 gdk_window_set_cursor (GdkWindow *window,
1465 GdkCursorPrivate *cursor_private;
1469 g_return_if_fail (window != NULL);
1470 g_return_if_fail (GDK_IS_WINDOW (window));
1472 cursor_private = (GdkCursorPrivate*) cursor;
1474 if (!GDK_DRAWABLE_DESTROYED (window))
1477 xcursor = LoadCursor (NULL, IDC_ARROW);
1479 xcursor = cursor_private->xcursor;
1481 GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
1482 GDK_DRAWABLE_XID (window), xcursor));
1483 GDK_WINDOW_WIN32DATA (window)->xcursor = xcursor;
1486 if (ChildWindowFromPoint (GDK_DRAWABLE_XID (window), pt) == GDK_DRAWABLE_XID (window))
1487 SetCursor (xcursor);
1492 gdk_window_get_geometry (GdkWindow *window,
1499 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1502 window = gdk_parent_root;
1504 if (!GDK_DRAWABLE_DESTROYED (window))
1508 if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
1509 WIN32_API_FAILED ("GetClientRect");
1516 *width = rect.right - rect.left;
1518 *height = rect.bottom - rect.top;
1520 *depth = gdk_drawable_get_visual (window)->depth;
1525 gdk_window_get_origin (GdkWindow *window,
1533 g_return_val_if_fail (window != NULL, 0);
1535 if (!GDK_DRAWABLE_DESTROYED (window))
1541 ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
1554 GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %#x: +%d+%d\n",
1555 GDK_DRAWABLE_XID (window), tx, ty));
1560 gdk_window_get_deskrelative_origin (GdkWindow *window,
1564 return gdk_window_get_origin (window, x, y);
1568 gdk_window_get_root_origin (GdkWindow *window,
1572 GdkWindowPrivate *rover;
1575 g_return_if_fail (window != NULL);
1576 g_return_if_fail (GDK_IS_WINDOW (window));
1578 rover = (GdkWindowPrivate*) window;
1583 if (GDK_DRAWABLE_DESTROYED (window))
1586 while (rover->parent && ((GdkWindowPrivate*) rover->parent)->parent)
1587 rover = (GdkWindowPrivate *) rover->parent;
1588 if (rover->drawable.destroyed)
1593 ClientToScreen (GDK_DRAWABLE_XID (rover), &pt);
1599 GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
1600 GDK_DRAWABLE_XID (window),
1601 GDK_DRAWABLE_XID (rover), pt.x, pt.y));
1605 gdk_window_get_pointer (GdkWindow *window,
1608 GdkModifierType *mask)
1610 GdkWindow *return_val;
1611 POINT pointc, point;
1614 g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1617 window = gdk_parent_root;
1620 GetCursorPos (&pointc);
1622 ScreenToClient (GDK_DRAWABLE_XID (window), &point);
1629 hwnd = WindowFromPoint (point);
1631 ScreenToClient (hwnd, &point);
1634 hwndc = ChildWindowFromPoint (hwnd, point);
1635 ClientToScreen (hwnd, &point);
1636 ScreenToClient (hwndc, &point);
1637 } while (hwndc != hwnd && (hwnd = hwndc, 1)); /* Ouch! */
1639 return_val = gdk_window_lookup (hwnd);
1645 GetKeyboardState (kbd);
1647 if (kbd[VK_SHIFT] & 0x80)
1648 *mask |= GDK_SHIFT_MASK;
1649 if (kbd[VK_CAPITAL] & 0x80)
1650 *mask |= GDK_LOCK_MASK;
1651 if (kbd[VK_CONTROL] & 0x80)
1652 *mask |= GDK_CONTROL_MASK;
1653 if (kbd[VK_MENU] & 0x80)
1654 *mask |= GDK_MOD1_MASK;
1655 if (kbd[VK_LBUTTON] & 0x80)
1656 *mask |= GDK_BUTTON1_MASK;
1657 if (kbd[VK_MBUTTON] & 0x80)
1658 *mask |= GDK_BUTTON2_MASK;
1659 if (kbd[VK_RBUTTON] & 0x80)
1660 *mask |= GDK_BUTTON3_MASK;
1667 gdk_window_at_pointer (gint *win_x,
1671 POINT point, pointc;
1675 GetCursorPos (&pointc);
1677 hwnd = WindowFromPoint (point);
1681 window = gdk_parent_root;
1689 ScreenToClient (hwnd, &point);
1692 hwndc = ChildWindowFromPoint (hwnd, point);
1693 ClientToScreen (hwnd, &point);
1694 ScreenToClient (hwndc, &point);
1695 } while (hwndc != hwnd && (hwnd = hwndc, 1));
1697 window = gdk_window_lookup (hwnd);
1699 if (window && (win_x || win_y))
1701 GetClientRect (hwnd, &rect);
1703 *win_x = point.x - rect.left;
1705 *win_y = point.y - rect.top;
1708 GDK_NOTE (MISC, g_print ("gdk_window_at_pointer: +%d+%d %#x%s\n",
1709 point.x, point.y, hwnd,
1710 (window == NULL ? " NULL" : "")));
1716 gdk_window_get_children (GdkWindow *window)
1718 GdkWindowPrivate *private;
1721 g_return_val_if_fail (window != NULL, NULL);
1722 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
1724 if (GDK_DRAWABLE_DESTROYED (window))
1728 g_warning ("gdk_window_get_children not implemented");
1735 gdk_window_get_events (GdkWindow *window)
1737 g_return_val_if_fail (window != NULL, 0);
1738 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
1740 if (GDK_DRAWABLE_DESTROYED (window))
1743 return GDK_WINDOW_WIN32DATA (window)->event_mask;
1747 gdk_window_set_events (GdkWindow *window,
1748 GdkEventMask event_mask)
1750 g_return_if_fail (window != NULL);
1751 g_return_if_fail (GDK_IS_WINDOW (window));
1753 if (GDK_DRAWABLE_DESTROYED (window))
1756 GDK_WINDOW_WIN32DATA (window)->event_mask = event_mask;
1760 gdk_window_add_colormap_windows (GdkWindow *window)
1762 g_warning ("gdk_window_add_colormap_windows not implemented");
1766 gdk_window_shape_combine_mask (GdkWindow *window,
1770 g_return_if_fail (window != NULL);
1771 g_return_if_fail (GDK_IS_WINDOW (window));
1775 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x none\n",
1776 GDK_DRAWABLE_XID (window)));
1777 SetWindowRgn (GDK_DRAWABLE_XID (window), NULL, TRUE);
1786 /* Convert mask bitmap to region */
1787 hrgn = BitmapToRegion (GDK_DRAWABLE_XID (mask));
1789 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
1790 GDK_DRAWABLE_XID (window),
1791 GDK_DRAWABLE_XID (mask)));
1793 /* SetWindowRgn wants window (not client) coordinates */
1794 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1795 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1796 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1797 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1798 OffsetRgn (hrgn, -rect.left, -rect.top);
1800 OffsetRgn (hrgn, x, y);
1802 /* If this is a top-level window, add the title bar to the region */
1803 if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
1805 CombineRgn (hrgn, hrgn,
1806 CreateRectRgn (0, 0, rect.right - rect.left, -rect.top),
1810 SetWindowRgn (GDK_DRAWABLE_XID (window), hrgn, TRUE);
1815 gdk_window_set_override_redirect (GdkWindow *window,
1816 gboolean override_redirect)
1818 g_return_if_fail (window != NULL);
1819 g_return_if_fail (GDK_IS_WINDOW (window));
1821 g_warning ("gdk_window_set_override_redirect not implemented");
1825 gdk_window_set_icon (GdkWindow *window,
1826 GdkWindow *icon_window,
1830 g_return_if_fail (window != NULL);
1831 g_return_if_fail (GDK_IS_WINDOW (window));
1833 if (GDK_DRAWABLE_DESTROYED (window))
1836 /* Nothing to do, really. As we share window classes between windows
1837 * we can't have window-specific icons, sorry. Don't print any warning
1843 gdk_window_set_icon_name (GdkWindow *window,
1846 g_return_if_fail (window != NULL);
1847 g_return_if_fail (GDK_IS_WINDOW (window));
1849 if (GDK_DRAWABLE_DESTROYED (window))
1852 if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
1853 WIN32_API_FAILED ("SetWindowText");
1857 gdk_window_set_group (GdkWindow *window,
1860 g_return_if_fail (window != NULL);
1861 g_return_if_fail (GDK_IS_WINDOW (window));
1862 g_return_if_fail (leader != NULL);
1863 g_return_if_fail (GDK_IS_WINDOW (leader));
1865 if (GDK_DRAWABLE_DESTROYED (window) || GDK_DRAWABLE_DESTROYED (leader))
1868 g_warning ("gdk_window_set_group not implemented");
1872 gdk_window_set_decorations (GdkWindow *window,
1873 GdkWMDecoration decorations)
1875 LONG style, exstyle;
1877 g_return_if_fail (window != NULL);
1878 g_return_if_fail (GDK_IS_WINDOW (window));
1880 style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1881 exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1883 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
1884 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
1886 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
1888 if (decorations & GDK_DECOR_ALL)
1889 style |= (WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
1890 if (decorations & GDK_DECOR_BORDER)
1891 style |= (WS_BORDER);
1892 if (decorations & GDK_DECOR_RESIZEH)
1893 style |= (WS_THICKFRAME);
1894 if (decorations & GDK_DECOR_TITLE)
1895 style |= (WS_CAPTION);
1896 if (decorations & GDK_DECOR_MENU)
1897 style |= (WS_SYSMENU);
1898 if (decorations & GDK_DECOR_MINIMIZE)
1899 style |= (WS_MINIMIZEBOX);
1900 if (decorations & GDK_DECOR_MAXIMIZE)
1901 style |= (WS_MAXIMIZEBOX);
1903 SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
1907 gdk_window_set_functions (GdkWindow *window,
1908 GdkWMFunction functions)
1910 LONG style, exstyle;
1912 g_return_if_fail (window != NULL);
1913 g_return_if_fail (GDK_IS_WINDOW (window));
1915 style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1916 exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1918 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
1919 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
1922 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
1924 if (functions & GDK_FUNC_ALL)
1925 style |= (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
1926 if (functions & GDK_FUNC_RESIZE)
1927 style |= (WS_THICKFRAME);
1928 if (functions & GDK_FUNC_MOVE)
1929 style |= (WS_THICKFRAME);
1930 if (functions & GDK_FUNC_MINIMIZE)
1931 style |= (WS_MINIMIZEBOX);
1932 if (functions & GDK_FUNC_MAXIMIZE)
1933 style |= (WS_MAXIMIZEBOX);
1935 SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
1939 * propagate the shapes from all child windows of a GDK window to the parent
1940 * window. Shamelessly ripped from Enlightenment's code
1946 QueryTree (HWND hwnd,
1956 child = GetWindow (hwnd, GW_CHILD);
1958 child = GetWindow (child, GW_HWNDNEXT);
1961 } while (child != NULL);
1965 *children = g_new (HWND, n);
1966 for (i = 0; i < n; i++)
1969 child = GetWindow (hwnd, GW_CHILD);
1971 child = GetWindow (child, GW_HWNDNEXT);
1972 *children[i] = child;
1978 gdk_propagate_shapes (HANDLE win,
1982 HRGN region, childRegion;
1987 SetRectEmpty (&emptyRect);
1988 region = CreateRectRgnIndirect (&emptyRect);
1990 GetWindowRgn (win, region);
1992 QueryTree (win, &list, &num);
1995 WINDOWPLACEMENT placement;
1997 placement.length = sizeof (WINDOWPLACEMENT);
1998 /* go through all child windows and combine regions */
1999 for (i = 0; i < num; i++)
2001 GetWindowPlacement (list[i], &placement);
2002 if (placement.showCmd = SW_SHOWNORMAL)
2004 childRegion = CreateRectRgnIndirect (&emptyRect);
2005 GetWindowRgn (list[i], childRegion);
2006 CombineRgn (region, region, childRegion, RGN_OR);
2007 DeleteObject (childRegion);
2010 SetWindowRgn (win, region, TRUE);
2013 DeleteObject (region);
2017 gdk_window_set_child_shapes (GdkWindow *window)
2019 g_return_if_fail (window != NULL);
2020 g_return_if_fail (GDK_IS_WINDOW (window));
2022 if (GDK_DRAWABLE_DESTROYED (window))
2025 gdk_propagate_shapes (GDK_DRAWABLE_XID (window), FALSE);
2029 gdk_window_merge_child_shapes (GdkWindow *window)
2031 g_return_if_fail (window != NULL);
2032 g_return_if_fail (GDK_IS_WINDOW (window));
2034 if (GDK_DRAWABLE_DESTROYED (window))
2037 gdk_propagate_shapes (GDK_DRAWABLE_XID (window), TRUE);
2040 /* Support for windows that can be guffaw-scrolled
2041 * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
2045 gdk_window_gravity_works (void)
2047 enum { UNKNOWN, NO, YES };
2048 static gint gravity_works = UNKNOWN;
2050 if (gravity_works == UNKNOWN)
2057 attr.window_type = GDK_WINDOW_TEMP;
2058 attr.wclass = GDK_INPUT_OUTPUT;
2063 attr.event_mask = 0;
2065 parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
2067 attr.window_type = GDK_WINDOW_CHILD;
2068 child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
2070 gdk_window_set_static_win_gravity (child, TRUE);
2072 gdk_window_resize (parent, 100, 110);
2073 gdk_window_move (parent, 0, -10);
2074 gdk_window_move_resize (parent, 0, 0, 100, 100);
2076 gdk_window_resize (parent, 100, 110);
2077 gdk_window_move (parent, 0, -10);
2078 gdk_window_move_resize (parent, 0, 0, 100, 100);
2080 gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
2082 gdk_window_destroy (parent);
2083 gdk_window_destroy (child);
2085 gravity_works = ((y == -20) ? YES : NO);
2088 return (gravity_works == YES);
2092 gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
2094 g_return_if_fail (window != NULL);
2096 GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
2100 gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
2102 g_return_if_fail (window != NULL);
2105 g_print ("gdk_window_set_static_win_gravity: Not implemented\n"));
2108 /*************************************************************
2109 * gdk_window_set_static_gravities:
2110 * Set the bit gravity of the given window to static,
2111 * and flag it so all children get static subwindow
2114 * window: window for which to set static gravity
2115 * use_static: Whether to turn static gravity on or off.
2117 * Does the XServer support static gravity?
2118 *************************************************************/
2121 gdk_window_set_static_gravities (GdkWindow *window,
2122 gboolean use_static)
2124 GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2127 g_return_val_if_fail (window != NULL, FALSE);
2128 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2130 if (!use_static == !private->guffaw_gravity)
2133 if (use_static && !gdk_window_gravity_works ())
2136 private->guffaw_gravity = use_static;
2138 if (!GDK_DRAWABLE_DESTROYED (window))
2140 gdk_window_set_static_bit_gravity (window, use_static);
2142 tmp_list = private->children;
2145 gdk_window_set_static_win_gravity (window, use_static);
2147 tmp_list = tmp_list->next;