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))
57 lpRect->right -= lpRect->left;
62 lpRect->bottom -= lpRect->top;
69 gdk_win32_window_destroy (GdkDrawable *drawable)
71 if (!GDK_DRAWABLE_DESTROYED (drawable))
73 if (GDK_DRAWABLE_TYPE (drawable) == GDK_WINDOW_FOREIGN)
74 gdk_xid_table_remove (GDK_DRAWABLE_XID (drawable));
76 g_warning ("losing last reference to undestroyed window\n");
79 if (GDK_WINDOW_WIN32DATA (drawable)->bg_type == GDK_WIN32_BG_PIXMAP
80 && GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap != NULL)
81 gdk_drawable_unref (GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap);
83 g_free (GDK_DRAWABLE_WIN32DATA (drawable));
87 gdk_win32_window_alloc (void)
90 GdkWindowPrivate *private;
92 static GdkDrawableClass klass;
93 static gboolean initialized = FALSE;
99 klass = _gdk_win32_drawable_class;
100 klass.destroy = gdk_win32_window_destroy;
103 window = _gdk_window_alloc ();
104 private = (GdkWindowPrivate *) window;
106 private->drawable.klass = &klass;
107 private->drawable.klass_data = g_new (GdkWindowWin32Data, 1);
109 GDK_WINDOW_WIN32DATA (window)->event_mask = 0;
110 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
111 GDK_WINDOW_WIN32DATA (window)->xcursor = NULL;
112 GDK_WINDOW_WIN32DATA (window)->hint_flags = 0;
113 GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
115 GDK_WINDOW_WIN32DATA (window)->input_locale = GetKeyboardLayout (0);
116 TranslateCharsetInfo ((DWORD FAR *) GetACP (),
117 &GDK_WINDOW_WIN32DATA (window)->charset_info,
124 gdk_window_init (void)
126 GdkWindowPrivate *private;
131 SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
132 width = r.right - r.left;
133 height = r.bottom - r.top;
135 gdk_parent_root = gdk_win32_window_alloc ();
136 private = (GdkWindowPrivate *) gdk_parent_root;
138 GDK_DRAWABLE_WIN32DATA (gdk_parent_root)->xid = gdk_root_window;
139 private->drawable.window_type = GDK_WINDOW_ROOT;
140 private->drawable.width = width;
141 private->drawable.height = height;
143 gdk_xid_table_insert (&gdk_root_window, gdk_parent_root);
147 * is a wrapper function for RegisterWindowClassEx.
148 * It creates at least one unique class for every
149 * GdkWindowType. If support for single window-specific icons
150 * is ever needed (e.g Dialog specific), every such window should
154 RegisterGdkClass (GdkDrawableType wtype)
156 static ATOM klassTOPLEVEL = 0;
157 static ATOM klassDIALOG = 0;
158 static ATOM klassCHILD = 0;
159 static ATOM klassTEMP = 0;
160 static HICON hAppIcon = NULL;
161 static WNDCLASSEX wcl;
164 wcl.cbSize = sizeof(WNDCLASSEX);
165 wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
166 * on WM_SIZE and WM_MOVE. Flicker, Performance!
168 wcl.lpfnWndProc = gdk_WindowProc;
171 wcl.hInstance = gdk_ProgInstance;
173 /* initialize once! */
176 gchar sLoc [_MAX_PATH+1];
177 HINSTANCE hInst = GetModuleHandle(NULL);
179 if (0 != GetModuleFileName(hInst, sLoc, _MAX_PATH))
181 hAppIcon = ExtractIcon(hInst, sLoc, 0);
184 char *gdklibname = g_strdup_printf ("gdk-%s.dll", GDK_VERSION);
186 hAppIcon = ExtractIcon(hInst, gdklibname, 0);
191 hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
195 wcl.lpszMenuName = NULL;
198 /* initialize once per class */
199 #define ONCE_PER_CLASS() \
200 wcl.hIcon = CopyIcon (hAppIcon); \
201 wcl.hIconSm = CopyIcon (hAppIcon); \
202 wcl.hbrBackground = CreateSolidBrush( RGB(0,0,0)); \
203 wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
207 case GDK_WINDOW_TOPLEVEL:
208 if (0 == klassTOPLEVEL)
210 wcl.lpszClassName = "gdkWindowToplevel";
213 klassTOPLEVEL = RegisterClassEx(&wcl);
215 klass = klassTOPLEVEL;
217 case GDK_WINDOW_CHILD:
220 wcl.lpszClassName = "gdkWindowChild";
222 wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
224 klassCHILD = RegisterClassEx(&wcl);
228 case GDK_WINDOW_DIALOG:
229 if (0 == klassDIALOG)
231 wcl.lpszClassName = "gdkWindowDialog";
232 wcl.style |= CS_SAVEBITS;
234 klassDIALOG = RegisterClassEx(&wcl);
238 case GDK_WINDOW_TEMP:
241 wcl.lpszClassName = "gdkWindowTemp";
242 wcl.style |= CS_SAVEBITS;
244 klassTEMP = RegisterClassEx(&wcl);
248 case GDK_WINDOW_ROOT:
249 g_error ("cannot make windows of type GDK_WINDOW_ROOT");
251 case GDK_DRAWABLE_PIXMAP:
252 g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
260 gdk_window_new (GdkWindow *parent,
261 GdkWindowAttr *attributes,
262 gint attributes_mask)
265 GdkWindowPrivate *private;
266 GdkWindowPrivate *parent_private;
271 DWORD dwStyle, dwExStyle;
281 g_return_val_if_fail (attributes != NULL, NULL);
284 parent = gdk_parent_root;
286 parent_private = (GdkWindowPrivate*) parent;
287 if (GDK_DRAWABLE_DESTROYED (parent))
290 xparent = GDK_DRAWABLE_XID (parent);
292 window = gdk_win32_window_alloc ();
293 private = (GdkWindowPrivate *)window;
295 private->parent = parent;
297 private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
298 private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
300 private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
301 private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
302 private->drawable.window_type = attributes->window_type;
303 GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
305 if (attributes_mask & GDK_WA_VISUAL)
306 visual = attributes->visual;
308 visual = gdk_visual_get_system ();
309 xvisual = ((GdkVisualPrivate*) visual)->xvisual;
311 if (attributes_mask & GDK_WA_TITLE)
312 title = attributes->title;
314 title = g_get_prgname ();
316 title = "GDK client window";
318 GDK_WINDOW_WIN32DATA (window)->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
320 if (parent_private && parent_private->guffaw_gravity)
325 if (attributes->wclass == GDK_INPUT_OUTPUT)
328 if (attributes_mask & GDK_WA_COLORMAP)
329 private->drawable.colormap = attributes->colormap;
331 private->drawable.colormap = gdk_colormap_get_system ();
335 dwExStyle = WS_EX_TRANSPARENT;
336 private->drawable.colormap = NULL;
337 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_TRANSPARENT;
338 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
341 if (attributes_mask & GDK_WA_X)
346 if (attributes_mask & GDK_WA_Y)
348 else if (attributes_mask & GDK_WA_X)
349 y = 100; /* ??? We must put it somewhere... */
351 y = 500; /* x is CW_USEDEFAULT, y doesn't matter then */
354 parent_private->children = g_list_prepend (parent_private->children, window);
356 switch (private->drawable.window_type)
358 case GDK_WINDOW_TOPLEVEL:
359 dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
360 xparent = gdk_root_window;
362 case GDK_WINDOW_CHILD:
363 dwStyle = WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
365 case GDK_WINDOW_DIALOG:
366 dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
368 dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
370 xparent = gdk_root_window;
372 case GDK_WINDOW_TEMP:
373 dwStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
374 dwExStyle |= WS_EX_TOOLWINDOW;
376 case GDK_WINDOW_ROOT:
377 g_error ("cannot make windows of type GDK_WINDOW_ROOT");
379 case GDK_DRAWABLE_PIXMAP:
380 g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
384 klass = RegisterGdkClass (private->drawable.window_type);
386 g_error ("RegisterClassEx failed");
388 if (private->drawable.window_type != GDK_WINDOW_CHILD)
390 if (x == CW_USEDEFAULT)
401 rect.right = rect.left + private->drawable.width;
402 rect.bottom = rect.top + private->drawable.height;
404 if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
405 g_warning ("gdk_window_new: AdjustWindowRectEx failed");
407 if (x != CW_USEDEFAULT)
412 width = rect.right - rect.left;
413 height = rect.bottom - rect.top;
417 width = private->drawable.width;
418 height = private->drawable.height;
421 titlelen = strlen (title);
422 wctitle = g_new (wchar_t, titlelen + 1);
423 mbtitle = g_new (char, 3*titlelen + 1);
424 wlen = gdk_nmbstowchar_ts (wctitle, title, titlelen, titlelen);
426 WideCharToMultiByte (GetACP (), 0, wctitle, -1,
427 mbtitle, 3*titlelen, NULL, NULL);
429 GDK_DRAWABLE_WIN32DATA (window)->xid =
430 CreateWindowEx (dwExStyle,
431 MAKEINTRESOURCE(klass),
442 g_print ("gdk_window_create: %s %s %dx%d@+%d+%d %#x = %#x\n"
443 "...locale %#x codepage %d\n",
444 (private->drawable.window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
445 (private->drawable.window_type == GDK_WINDOW_CHILD ? "CHILD" :
446 (private->drawable.window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
447 (private->drawable.window_type == GDK_WINDOW_TEMP ? "TEMP" :
450 width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
452 GDK_DRAWABLE_XID (window),
453 GDK_WINDOW_WIN32DATA (window)->input_locale,
454 GDK_WINDOW_WIN32DATA (window)->charset_info.ciACP));
459 if (GDK_DRAWABLE_XID (window) == NULL)
461 g_warning ("gdk_window_create: CreateWindowEx failed");
462 g_free (GDK_DRAWABLE_WIN32DATA (window));
467 gdk_drawable_ref (window);
468 gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
470 if (private->drawable.colormap)
471 gdk_colormap_ref (private->drawable.colormap);
473 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
474 (attributes->cursor) :
481 gdk_window_foreign_new (guint32 anid)
484 GdkWindowPrivate *private;
485 GdkWindowPrivate *parent_private;
490 window = gdk_win32_window_alloc ();
491 private = (GdkWindowPrivate *)window;
493 parent = GetParent ((HWND) anid);
494 private->parent = gdk_xid_table_lookup (parent);
496 parent_private = (GdkWindowPrivate *)private->parent;
499 parent_private->children = g_list_prepend (parent_private->children, window);
501 GDK_DRAWABLE_WIN32DATA (window)->xid = (HWND) anid;
502 GetClientRect ((HWND) anid, &rect);
504 point.y = rect.right;
505 ClientToScreen ((HWND) anid, &point);
506 if (parent != GetDesktopWindow ())
507 ScreenToClient (parent, &point);
508 private->x = point.x;
509 private->y = point.y;
510 private->drawable.width = rect.right - rect.left;
511 private->drawable.height = rect.bottom - rect.top;
512 private->drawable.window_type = GDK_WINDOW_FOREIGN;
513 private->drawable.destroyed = FALSE;
514 private->mapped = IsWindowVisible (GDK_DRAWABLE_XID (window));
516 private->drawable.colormap = NULL;
518 gdk_drawable_ref (window);
519 gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
524 /* Call this function when you want a window and all its children to
525 * disappear. When xdestroy is true, a request to destroy the window
526 * is sent out. When it is false, it is assumed that the window has
527 * been or will be destroyed by destroying some ancestor of this
531 gdk_window_internal_destroy (GdkWindow *window,
533 gboolean our_destroy)
535 GdkWindowPrivate *private;
536 GdkWindowPrivate *temp_private;
537 GdkWindow *temp_window;
541 g_return_if_fail (window != NULL);
543 private = (GdkWindowPrivate *) window;
545 GDK_NOTE (MISC, g_print ("gdk_window_internal_destroy %#x\n",
546 GDK_DRAWABLE_XID (window)));
548 switch (GDK_DRAWABLE_TYPE (window))
550 case GDK_WINDOW_TOPLEVEL:
551 case GDK_WINDOW_CHILD:
552 case GDK_WINDOW_DIALOG:
553 case GDK_WINDOW_TEMP:
554 case GDK_WINDOW_FOREIGN:
555 if (!private->drawable.destroyed)
559 GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
560 if (parent_private->children)
561 parent_private->children = g_list_remove (parent_private->children, window);
564 if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
566 children = tmp = private->children;
567 private->children = NULL;
571 temp_window = tmp->data;
574 temp_private = (GdkWindowPrivate*) temp_window;
576 gdk_window_internal_destroy (temp_window, FALSE,
580 g_list_free (children);
583 if (private->extension_events != 0)
584 gdk_input_window_destroy (window);
586 if (private->filters)
588 tmp = private->filters;
596 g_list_free (private->filters);
597 private->filters = NULL;
600 if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
602 if (our_destroy && (private->parent != NULL))
604 /* It's somebody elses window, but in our hierarchy,
605 * so reparent it to the root window, and then send
606 * it a delete event, as if we were a WM
608 gdk_window_hide (window);
609 gdk_window_reparent (window, NULL, 0, 0);
611 /* Is this too drastic? Many (most?) applications
612 * quit if any window receives WM_QUIT I think.
613 * OTOH, I don't think foreign windows are much
614 * used, so the question is maybe academic.
616 PostMessage (GDK_DRAWABLE_XID (window), WM_QUIT, 0, 0);
620 DestroyWindow (GDK_DRAWABLE_XID (window));
622 if (private->drawable.colormap)
623 gdk_colormap_unref (private->drawable.colormap);
625 private->mapped = FALSE;
626 private->drawable.destroyed = TRUE;
630 case GDK_WINDOW_ROOT:
631 g_error ("attempted to destroy root window");
634 case GDK_DRAWABLE_PIXMAP:
635 g_error ("called gdk_window_destroy on a pixmap (use gdk_drawable_unref)");
640 /* Like internal_destroy, but also destroys the reference created by
644 gdk_window_destroy (GdkWindow *window)
646 gdk_window_internal_destroy (window, TRUE, TRUE);
647 gdk_drawable_unref (window);
650 /* This function is called when the window really gone. */
653 gdk_window_destroy_notify (GdkWindow *window)
655 g_return_if_fail (window != NULL);
658 g_print ("gdk_window_destroy_notify: %#x %s\n",
659 GDK_DRAWABLE_XID (window),
660 (GDK_DRAWABLE_DESTROYED (window) ? "yes" : "no")));
662 if (!GDK_DRAWABLE_DESTROYED (window))
664 if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
665 g_warning ("window %#x unexpectedly destroyed",
666 GDK_DRAWABLE_XID (window));
668 gdk_window_internal_destroy (window, FALSE, FALSE);
671 gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
672 gdk_drawable_unref (window);
676 gdk_window_show (GdkWindow *window)
678 g_return_if_fail (window != NULL);
680 if (!GDK_DRAWABLE_DESTROYED (window))
682 GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
683 GDK_DRAWABLE_XID (window)));
685 ((GdkWindowPrivate *) window)->mapped = TRUE;
686 if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TEMP)
688 ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNOACTIVATE);
689 SetWindowPos (GDK_DRAWABLE_XID (window), HWND_TOPMOST, 0, 0, 0, 0,
690 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
692 /* Don't put on toolbar */
693 ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
698 ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNORMAL);
699 ShowWindow (GDK_DRAWABLE_XID (window), SW_RESTORE);
700 SetForegroundWindow (GDK_DRAWABLE_XID (window));
701 BringWindowToTop (GDK_DRAWABLE_XID (window));
703 ShowOwnedPopups (GDK_DRAWABLE_XID (window), TRUE);
710 gdk_window_hide (GdkWindow *window)
712 g_return_if_fail (window != NULL);
714 if (!GDK_DRAWABLE_DESTROYED (window))
716 GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
717 GDK_DRAWABLE_XID (window)));
719 ((GdkWindowPrivate *) window)->mapped = FALSE;
720 if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
721 ShowOwnedPopups (GDK_DRAWABLE_XID (window), FALSE);
723 ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
725 ShowWindow (GDK_DRAWABLE_XID (window), SW_MINIMIZE);
727 CloseWindow (GDK_DRAWABLE_XID (window));
733 gdk_window_withdraw (GdkWindow *window)
735 g_return_if_fail (window != NULL);
737 if (!GDK_DRAWABLE_DESTROYED (window))
739 GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
740 GDK_DRAWABLE_XID (window)));
742 gdk_window_hide (window); /* XXX */
747 gdk_window_move (GdkWindow *window,
751 GdkWindowPrivate *private;
753 g_return_if_fail (window != NULL);
755 if (!GDK_DRAWABLE_DESTROYED (window))
759 GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
760 GDK_DRAWABLE_XID (window), x, y));
762 private = (GdkWindowPrivate *) window;
763 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
765 if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
773 ClientToScreen (GDK_DRAWABLE_XID (window), &ptTL);
778 ptBR.y = rect.bottom;
779 ClientToScreen (GDK_DRAWABLE_XID (window), &ptBR);
780 rect.right = x + ptBR.x - ptTL.x;
781 rect.bottom = y + ptBR.y - ptTL.y;
783 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
784 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
785 if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
786 g_warning ("gdk_window_move: AdjustWindowRectEx failed");
796 GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
797 GDK_DRAWABLE_XID (window),
798 rect.right - rect.left, rect.bottom - rect.top,
800 if (!MoveWindow (GDK_DRAWABLE_XID (window),
801 x, y, rect.right - rect.left, rect.bottom - rect.top,
803 g_warning ("gdk_window_move: MoveWindow failed");
808 gdk_window_resize (GdkWindow *window,
812 GdkWindowPrivate *private;
814 g_return_if_fail (window != NULL);
816 if ((gint16) width < 1)
818 if ((gint16) height < 1)
821 private = (GdkWindowPrivate*) window;
823 if (!private->drawable.destroyed &&
824 ((private->resize_count > 0) ||
825 (private->drawable.width != (guint16) width) ||
826 (private->drawable.height != (guint16) height)))
830 GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
831 GDK_DRAWABLE_XID (window), width, height));
833 if (private->drawable.window_type != GDK_WINDOW_CHILD)
842 ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
845 rect.right = pt.x + width;
846 rect.bottom = pt.y + height;
848 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
849 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
850 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
851 g_warning ("gdk_window_resize: AdjustWindowRectEx failed");
855 width = rect.right - rect.left;
856 height = rect.bottom - rect.top;
862 private->drawable.width = width;
863 private->drawable.height = height;
866 private->resize_count += 1;
869 g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
870 GDK_DRAWABLE_XID (window), width, height, x, y));
871 if (!MoveWindow (GDK_DRAWABLE_XID (window),
874 g_warning ("gdk_window_resize: MoveWindow failed");
879 gdk_window_move_resize (GdkWindow *window,
885 GdkWindowPrivate *private;
887 g_return_if_fail (window != NULL);
889 if ((gint16) width < 1)
891 if ((gint16) height < 1)
894 if (!GDK_DRAWABLE_DESTROYED (window))
900 GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
901 GDK_DRAWABLE_XID (window), width, height, x, y));
903 private = (GdkWindowPrivate*) window;
906 rect.right = x + width;
907 rect.bottom = y + height;
909 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
910 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
911 if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
912 g_warning ("gdk_window_move_resize: AdjustWindowRectEx failed");
914 if (private->drawable.window_type == GDK_WINDOW_CHILD)
918 private->drawable.width = width;
919 private->drawable.height = height;
921 GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
922 GDK_DRAWABLE_XID (window),
923 rect.right - rect.left, rect.bottom - rect.top,
924 rect.left, rect.top));
925 if (!MoveWindow (GDK_DRAWABLE_XID (window),
927 rect.right - rect.left, rect.bottom - rect.top,
929 g_warning ("gdk_window_move_resize: MoveWindow failed");
931 if (private->guffaw_gravity)
933 GList *tmp_list = private->children;
936 GdkWindowPrivate *child_private = tmp_list->data;
938 child_private->x -= x - private->x;
939 child_private->y -= y - private->y;
941 tmp_list = tmp_list->next;
949 gdk_window_reparent (GdkWindow *window,
950 GdkWindow *new_parent,
954 GdkWindowPrivate *window_private;
955 GdkWindowPrivate *parent_private;
956 GdkWindowPrivate *old_parent_private;
958 g_return_if_fail (window != NULL);
961 new_parent = gdk_parent_root;
963 window_private = (GdkWindowPrivate*) window;
964 old_parent_private = (GdkWindowPrivate *) window_private->parent;
965 parent_private = (GdkWindowPrivate*) new_parent;
967 if (!GDK_DRAWABLE_DESTROYED (window)
968 && !GDK_DRAWABLE_DESTROYED (new_parent))
970 GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
971 GDK_DRAWABLE_XID (window),
972 GDK_DRAWABLE_XID (new_parent)));
973 if (!SetParent (GDK_DRAWABLE_XID (window),
974 GDK_DRAWABLE_XID (new_parent)))
975 g_warning ("gdk_window_reparent: SetParent failed");
977 if (!MoveWindow (GDK_DRAWABLE_XID (window),
979 window_private->drawable.width,
980 window_private->drawable.height,
982 g_warning ("gdk_window_reparent: MoveWindow failed");
985 window_private->parent = new_parent;
987 if (old_parent_private)
988 old_parent_private->children =
989 g_list_remove (old_parent_private->children, window);
991 if ((old_parent_private &&
992 (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
993 (!old_parent_private && parent_private->guffaw_gravity))
994 gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
996 parent_private->children = g_list_prepend (parent_private->children, window);
1000 gdk_window_clear (GdkWindow *window)
1002 g_return_if_fail (window != NULL);
1003 g_return_if_fail (GDK_IS_WINDOW (window));
1005 if (!GDK_DRAWABLE_DESTROYED (window))
1006 gdk_window_clear_area (window, 0, 0, 0, 0);
1011 gdk_window_clear_area (GdkWindow *window,
1017 g_return_if_fail (window != NULL);
1018 g_return_if_fail (GDK_IS_WINDOW (window));
1020 if (!GDK_DRAWABLE_DESTROYED (window))
1025 width = ((GdkDrawablePrivate *) window)->width - x;
1027 height = ((GdkDrawablePrivate *) window)->height - y;
1028 GDK_NOTE (MISC, g_print ("gdk_window_clear_area: %#x %dx%d@+%d+%d\n",
1029 GDK_DRAWABLE_XID (window), width, height, x, y));
1030 hdc = GetDC (GDK_DRAWABLE_XID (window));
1031 IntersectClipRect (hdc, x, y, x + width, y + height);
1032 SendMessage (GDK_DRAWABLE_XID (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
1033 ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
1038 gdk_window_clear_area_e (GdkWindow *window,
1044 g_return_if_fail (window != NULL);
1045 g_return_if_fail (GDK_IS_WINDOW (window));
1047 if (!GDK_DRAWABLE_DESTROYED (window))
1051 GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
1052 GDK_DRAWABLE_XID (window), width, height, x, y));
1055 rect.right = x + width;
1057 rect.bottom = y + height;
1058 if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
1059 g_warning ("gdk_window_clear_area_e: InvalidateRect failed");
1060 UpdateWindow (GDK_DRAWABLE_XID (window));
1065 gdk_window_raise (GdkWindow *window)
1067 g_return_if_fail (window != NULL);
1068 g_return_if_fail (GDK_IS_WINDOW (window));
1070 if (!GDK_DRAWABLE_DESTROYED (window))
1072 GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n",
1073 GDK_DRAWABLE_XID (window)));
1075 if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
1076 g_warning ("gdk_window_raise: BringWindowToTop failed");
1081 gdk_window_lower (GdkWindow *window)
1083 g_return_if_fail (window != NULL);
1084 g_return_if_fail (GDK_IS_WINDOW (window));
1086 if (!GDK_DRAWABLE_DESTROYED (window))
1088 GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n",
1089 GDK_DRAWABLE_XID (window)));
1091 if (!SetWindowPos (GDK_DRAWABLE_XID (window), HWND_BOTTOM, 0, 0, 0, 0,
1092 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
1093 g_warning ("gdk_window_lower: SetWindowPos failed");
1098 gdk_window_set_hints (GdkWindow *window,
1107 WINDOWPLACEMENT size_hints;
1113 g_return_if_fail (window != NULL);
1114 g_return_if_fail (GDK_IS_WINDOW (window));
1116 if (GDK_DRAWABLE_DESTROYED (window))
1119 GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
1120 GDK_DRAWABLE_XID (window),
1121 min_width, min_height, max_width, max_height,
1124 GDK_WINDOW_WIN32DATA (window)->hint_flags = flags;
1125 size_hints.length = sizeof (size_hints);
1129 if (flags & GDK_HINT_POS)
1130 if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1131 g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
1134 GDK_NOTE (MISC, g_print ("...rcNormalPosition:"
1135 " (%d,%d)--(%d,%d)\n",
1136 size_hints.rcNormalPosition.left,
1137 size_hints.rcNormalPosition.top,
1138 size_hints.rcNormalPosition.right,
1139 size_hints.rcNormalPosition.bottom));
1140 /* What are the corresponding window coordinates for client
1141 * area coordinates x, y
1145 rect.right = rect.left + 200; /* dummy */
1146 rect.bottom = rect.top + 200;
1147 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1148 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1149 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1150 size_hints.flags = 0;
1151 size_hints.showCmd = SW_SHOWNA;
1153 /* Set the normal position hint to that location, with unchanged
1156 diff = size_hints.rcNormalPosition.left - rect.left;
1157 size_hints.rcNormalPosition.left = rect.left;
1158 size_hints.rcNormalPosition.right -= diff;
1159 diff = size_hints.rcNormalPosition.top - rect.top;
1160 size_hints.rcNormalPosition.top = rect.top;
1161 size_hints.rcNormalPosition.bottom -= diff;
1162 GDK_NOTE (MISC, g_print ("...setting: (%d,%d)--(%d,%d)\n",
1163 size_hints.rcNormalPosition.left,
1164 size_hints.rcNormalPosition.top,
1165 size_hints.rcNormalPosition.right,
1166 size_hints.rcNormalPosition.bottom));
1167 if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1168 g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
1169 GDK_WINDOW_WIN32DATA (window)->hint_x = rect.left;
1170 GDK_WINDOW_WIN32DATA (window)->hint_y = rect.top;
1173 if (flags & GDK_HINT_MIN_SIZE)
1177 rect.right = min_width;
1178 rect.bottom = min_height;
1179 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1180 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1181 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1182 GDK_WINDOW_WIN32DATA (window)->hint_min_width =
1183 rect.right - rect.left;
1184 GDK_WINDOW_WIN32DATA (window)->hint_min_height =
1185 rect.bottom - rect.top;
1187 /* Also chek if he current size of the window is in bounds. */
1188 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1189 if (rect.right < min_width && rect.bottom < min_height)
1190 gdk_window_resize (window, min_width, min_height);
1191 else if (rect.right < min_width)
1192 gdk_window_resize (window, min_width, rect.bottom);
1193 else if (rect.bottom < min_height)
1194 gdk_window_resize (window, rect.right, min_height);
1197 if (flags & GDK_HINT_MAX_SIZE)
1201 rect.right = max_width;
1202 rect.bottom = max_height;
1203 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1204 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1205 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1206 GDK_WINDOW_WIN32DATA (window)->hint_max_width =
1207 rect.right - rect.left;
1208 GDK_WINDOW_WIN32DATA (window)->hint_max_height =
1209 rect.bottom - rect.top;
1210 /* Again, check if the window is too large currently. */
1211 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1212 if (rect.right > max_width && rect.bottom > max_height)
1213 gdk_window_resize (window, max_width, max_height);
1214 else if (rect.right > max_width)
1215 gdk_window_resize (window, max_width, rect.bottom);
1216 else if (rect.bottom > max_height)
1217 gdk_window_resize (window, rect.right, max_height);
1223 gdk_window_set_geometry_hints (GdkWindow *window,
1224 GdkGeometry *geometry,
1225 GdkWindowHints geom_mask)
1227 WINDOWPLACEMENT size_hints;
1233 g_return_if_fail (window != NULL);
1234 g_return_if_fail (GDK_IS_WINDOW (window));
1236 if (GDK_DRAWABLE_DESTROYED (window))
1239 size_hints.length = sizeof (size_hints);
1241 GDK_WINDOW_WIN32DATA (window)->hint_flags = geom_mask;
1243 if (geom_mask & GDK_HINT_POS)
1246 if (geom_mask & GDK_HINT_MIN_SIZE)
1250 rect.right = geometry->min_width;
1251 rect.bottom = geometry->min_height;
1252 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1253 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1254 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1255 GDK_WINDOW_WIN32DATA (window)->hint_min_width = rect.right - rect.left;
1256 GDK_WINDOW_WIN32DATA (window)->hint_min_height = rect.bottom - rect.top;
1258 /* Also check if he current size of the window is in bounds */
1259 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1260 if (rect.right < geometry->min_width
1261 && rect.bottom < geometry->min_height)
1262 gdk_window_resize (window, geometry->min_width, geometry->min_height);
1263 else if (rect.right < geometry->min_width)
1264 gdk_window_resize (window, geometry->min_width, rect.bottom);
1265 else if (rect.bottom < geometry->min_height)
1266 gdk_window_resize (window, rect.right, geometry->min_height);
1269 if (geom_mask & GDK_HINT_MAX_SIZE)
1273 rect.right = geometry->max_width;
1274 rect.bottom = geometry->max_height;
1275 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1276 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1277 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1278 GDK_WINDOW_WIN32DATA (window)->hint_max_width = rect.right - rect.left;
1279 GDK_WINDOW_WIN32DATA (window)->hint_max_height = rect.bottom - rect.top;
1281 /* Again, check if the window is too large currently. */
1282 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1283 if (rect.right > geometry->max_width
1284 && rect.bottom > geometry->max_height)
1285 gdk_window_resize (window, geometry->max_width, geometry->max_height);
1286 else if (rect.right > geometry->max_width)
1287 gdk_window_resize (window, geometry->max_width, rect.bottom);
1288 else if (rect.bottom > geometry->max_height)
1289 gdk_window_resize (window, rect.right, geometry->max_height);
1292 /* I don't know what to do when called with zero base_width and height. */
1293 if (geom_mask & GDK_HINT_BASE_SIZE
1294 && geometry->base_width > 0
1295 && geometry->base_height > 0)
1296 if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1297 g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
1300 GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
1301 " rcNormalPosition: (%d,%d)--(%d,%d)\n",
1302 size_hints.rcNormalPosition.left,
1303 size_hints.rcNormalPosition.top,
1304 size_hints.rcNormalPosition.right,
1305 size_hints.rcNormalPosition.bottom));
1306 size_hints.rcNormalPosition.right =
1307 size_hints.rcNormalPosition.left + geometry->base_width;
1308 size_hints.rcNormalPosition.bottom =
1309 size_hints.rcNormalPosition.top + geometry->base_height;
1310 GDK_NOTE (MISC, g_print ("...setting: rcNormal: (%d,%d)--(%d,%d)\n",
1311 size_hints.rcNormalPosition.left,
1312 size_hints.rcNormalPosition.top,
1313 size_hints.rcNormalPosition.right,
1314 size_hints.rcNormalPosition.bottom));
1315 if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
1316 g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
1319 if (geom_mask & GDK_HINT_RESIZE_INC)
1324 if (geom_mask & GDK_HINT_ASPECT)
1331 gdk_window_set_title (GdkWindow *window,
1339 g_return_if_fail (window != NULL);
1340 g_return_if_fail (GDK_IS_WINDOW (window));
1342 GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
1343 GDK_DRAWABLE_XID (window), title));
1344 if (!GDK_DRAWABLE_DESTROYED (window))
1346 /* As the title is in UTF-8 we must translate it
1347 * to the system codepage.
1349 titlelen = strlen (title);
1350 wcstr = g_new (wchar_t, titlelen + 1);
1351 mbstr = g_new (char, 3*titlelen + 1);
1352 wlen = gdk_nmbstowchar_ts (wcstr, title, titlelen, titlelen);
1354 WideCharToMultiByte (GetACP (), 0, wcstr, -1,
1355 mbstr, 3*titlelen, NULL, NULL);
1357 if (!SetWindowText (GDK_DRAWABLE_XID (window), mbstr))
1358 g_warning ("gdk_window_set_title: SetWindowText failed");
1366 gdk_window_set_role (GdkWindow *window,
1369 g_return_if_fail (window != NULL);
1370 g_return_if_fail (GDK_IS_WINDOW (window));
1372 GDK_NOTE (MISC, g_print ("gdk_window_set_role: %#x %s\n",
1373 GDK_DRAWABLE_XID (window), (role ? role : "NULL")));
1378 gdk_window_set_transient_for (GdkWindow *window,
1381 g_return_if_fail (window != NULL);
1382 g_return_if_fail (GDK_IS_WINDOW (window));
1384 GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %#x %#x\n",
1385 GDK_DRAWABLE_XID (window),
1386 GDK_DRAWABLE_XID (parent)));
1391 gdk_window_set_background (GdkWindow *window,
1394 g_return_if_fail (window != NULL);
1395 g_return_if_fail (GDK_IS_WINDOW (window));
1397 if (!GDK_DRAWABLE_DESTROYED (window))
1399 GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
1400 GDK_DRAWABLE_XID (window),
1401 gdk_color_to_string (color)));
1403 if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
1405 if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
1407 gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
1408 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
1410 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
1412 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXEL;
1413 GDK_WINDOW_WIN32DATA (window)->bg_pixel = *color;
1418 gdk_window_set_back_pixmap (GdkWindow *window,
1420 gint parent_relative)
1422 g_return_if_fail (window != NULL);
1423 g_return_if_fail (GDK_IS_WINDOW (window));
1425 if (!GDK_DRAWABLE_DESTROYED (window))
1427 if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
1429 if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
1431 gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
1432 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
1434 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
1436 if (parent_relative)
1438 GDK_WINDOW_WIN32DATA (window)->bg_type =
1439 GDK_WIN32_BG_PARENT_RELATIVE;
1447 /* We must cache the pixmap in the GdkWindowWin32Data and
1448 * paint it each time we get WM_ERASEBKGND
1450 GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXMAP;
1451 GDK_WINDOW_WIN32DATA (window)->bg_pixmap = pixmap;
1452 gdk_drawable_ref (pixmap);
1458 gdk_window_set_cursor (GdkWindow *window,
1461 GdkCursorPrivate *cursor_private;
1464 g_return_if_fail (window != NULL);
1465 g_return_if_fail (GDK_IS_WINDOW (window));
1467 cursor_private = (GdkCursorPrivate*) cursor;
1469 if (!GDK_DRAWABLE_DESTROYED (window))
1472 xcursor = LoadCursor (NULL, IDC_ARROW);
1474 xcursor = cursor_private->xcursor;
1476 GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
1477 GDK_DRAWABLE_XID (window), xcursor));
1478 GDK_WINDOW_WIN32DATA (window)->xcursor = xcursor;
1483 gdk_window_get_geometry (GdkWindow *window,
1490 g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
1493 window = gdk_parent_root;
1495 if (!GDK_DRAWABLE_DESTROYED (window))
1499 if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
1500 g_warning ("gdk_window_get_geometry: GetClientRect failed");
1507 *width = rect.right - rect.left;
1509 *height = rect.bottom - rect.top;
1511 *depth = gdk_drawable_get_visual (window)->depth;
1516 gdk_window_get_origin (GdkWindow *window,
1524 g_return_val_if_fail (window != NULL, 0);
1526 if (!GDK_DRAWABLE_DESTROYED (window))
1532 ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
1545 GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %#x: +%d+%d\n",
1546 GDK_DRAWABLE_XID (window), tx, ty));
1551 gdk_window_get_deskrelative_origin (GdkWindow *window,
1555 return gdk_window_get_origin (window, x, y);
1559 gdk_window_get_root_origin (GdkWindow *window,
1563 GdkWindowPrivate *rover;
1566 g_return_if_fail (window != NULL);
1567 g_return_if_fail (GDK_IS_WINDOW (window));
1569 rover = (GdkWindowPrivate*) window;
1574 if (GDK_DRAWABLE_DESTROYED (window))
1577 while (rover->parent && ((GdkWindowPrivate*) rover->parent)->parent)
1578 rover = (GdkWindowPrivate *) rover->parent;
1579 if (rover->drawable.destroyed)
1584 ClientToScreen (GDK_DRAWABLE_XID (rover), &pt);
1590 GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
1591 GDK_DRAWABLE_XID (window),
1592 GDK_DRAWABLE_XID (rover), pt.x, pt.y));
1596 gdk_window_get_pointer (GdkWindow *window,
1599 GdkModifierType *mask)
1601 GdkWindow *return_val;
1602 POINT pointc, point;
1605 g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1608 window = gdk_parent_root;
1611 GetCursorPos (&pointc);
1613 ScreenToClient (GDK_DRAWABLE_XID (window), &point);
1620 hwnd = WindowFromPoint (point);
1622 ScreenToClient (hwnd, &point);
1625 hwndc = ChildWindowFromPoint (hwnd, point);
1626 ClientToScreen (hwnd, &point);
1627 ScreenToClient (hwndc, &point);
1628 } while (hwndc != hwnd && (hwnd = hwndc, 1)); /* Ouch! */
1630 return_val = gdk_window_lookup (hwnd);
1636 GetKeyboardState (kbd);
1638 if (kbd[VK_SHIFT] & 0x80)
1639 *mask |= GDK_SHIFT_MASK;
1640 if (kbd[VK_CAPITAL] & 0x80)
1641 *mask |= GDK_LOCK_MASK;
1642 if (kbd[VK_CONTROL] & 0x80)
1643 *mask |= GDK_CONTROL_MASK;
1644 if (kbd[VK_MENU] & 0x80)
1645 *mask |= GDK_MOD1_MASK;
1646 if (kbd[VK_LBUTTON] & 0x80)
1647 *mask |= GDK_BUTTON1_MASK;
1648 if (kbd[VK_MBUTTON] & 0x80)
1649 *mask |= GDK_BUTTON2_MASK;
1650 if (kbd[VK_RBUTTON] & 0x80)
1651 *mask |= GDK_BUTTON3_MASK;
1658 gdk_window_at_pointer (gint *win_x,
1662 POINT point, pointc;
1666 GetCursorPos (&pointc);
1668 hwnd = WindowFromPoint (point);
1672 window = gdk_parent_root;
1680 ScreenToClient (hwnd, &point);
1683 hwndc = ChildWindowFromPoint (hwnd, point);
1684 ClientToScreen (hwnd, &point);
1685 ScreenToClient (hwndc, &point);
1686 } while (hwndc != hwnd && (hwnd = hwndc, 1));
1688 window = gdk_window_lookup (hwnd);
1690 if (window && (win_x || win_y))
1692 GetClientRect (hwnd, &rect);
1694 *win_x = point.x - rect.left;
1696 *win_y = point.y - rect.top;
1699 GDK_NOTE (MISC, g_print ("gdk_window_at_pointer: +%d+%d %#x%s\n",
1700 point.x, point.y, hwnd,
1701 (window == NULL ? " NULL" : "")));
1707 gdk_window_get_children (GdkWindow *window)
1709 GdkWindowPrivate *private;
1712 g_return_val_if_fail (window != NULL, NULL);
1713 g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
1715 if (GDK_DRAWABLE_DESTROYED (window))
1719 g_warning ("gdk_window_get_children not implemented");
1726 gdk_window_get_events (GdkWindow *window)
1728 g_return_val_if_fail (window != NULL, 0);
1729 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
1731 if (GDK_DRAWABLE_DESTROYED (window))
1734 return GDK_WINDOW_WIN32DATA (window)->event_mask;
1738 gdk_window_set_events (GdkWindow *window,
1739 GdkEventMask event_mask)
1741 g_return_if_fail (window != NULL);
1742 g_return_if_fail (GDK_IS_WINDOW (window));
1744 if (GDK_DRAWABLE_DESTROYED (window))
1747 GDK_WINDOW_WIN32DATA (window)->event_mask = event_mask;
1751 gdk_window_add_colormap_windows (GdkWindow *window)
1753 g_warning ("gdk_window_add_colormap_windows not implemented");
1757 gdk_window_shape_combine_mask (GdkWindow *window,
1761 g_return_if_fail (window != NULL);
1762 g_return_if_fail (GDK_IS_WINDOW (window));
1766 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x none\n",
1767 GDK_DRAWABLE_XID (window)));
1768 SetWindowRgn (GDK_DRAWABLE_XID (window), NULL, TRUE);
1777 /* Convert mask bitmap to region */
1778 hrgn = BitmapToRegion (GDK_DRAWABLE_XID (mask));
1780 GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
1781 GDK_DRAWABLE_XID (window),
1782 GDK_DRAWABLE_XID (mask)));
1784 /* SetWindowRgn wants window (not client) coordinates */
1785 dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1786 dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1787 GetClientRect (GDK_DRAWABLE_XID (window), &rect);
1788 AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
1789 OffsetRgn (hrgn, -rect.left, -rect.top);
1791 OffsetRgn (hrgn, x, y);
1793 /* If this is a top-level window, add the title bar to the region */
1794 if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
1796 CombineRgn (hrgn, hrgn,
1797 CreateRectRgn (0, 0, rect.right - rect.left, -rect.top),
1801 SetWindowRgn (GDK_DRAWABLE_XID (window), hrgn, TRUE);
1806 gdk_window_set_override_redirect (GdkWindow *window,
1807 gboolean override_redirect)
1809 g_return_if_fail (window != NULL);
1810 g_return_if_fail (GDK_IS_WINDOW (window));
1812 g_warning ("gdk_window_set_override_redirect not implemented");
1816 gdk_window_set_icon (GdkWindow *window,
1817 GdkWindow *icon_window,
1821 g_return_if_fail (window != NULL);
1822 g_return_if_fail (GDK_IS_WINDOW (window));
1824 if (GDK_DRAWABLE_DESTROYED (window))
1827 g_warning ("gdk_window_set_icon not implemented");
1831 gdk_window_set_icon_name (GdkWindow *window,
1834 g_return_if_fail (window != NULL);
1835 g_return_if_fail (GDK_IS_WINDOW (window));
1837 if (GDK_DRAWABLE_DESTROYED (window))
1840 if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
1841 g_warning ("gdk_window_set_icon_name: SetWindowText failed");
1845 gdk_window_set_group (GdkWindow *window,
1848 g_return_if_fail (window != NULL);
1849 g_return_if_fail (GDK_IS_WINDOW (window));
1850 g_return_if_fail (leader != NULL);
1851 g_return_if_fail (GDK_IS_WINDOW (leader));
1853 if (GDK_DRAWABLE_DESTROYED (window) || GDK_DRAWABLE_DESTROYED (leader))
1856 g_warning ("gdk_window_set_group not implemented");
1860 gdk_window_set_decorations (GdkWindow *window,
1861 GdkWMDecoration decorations)
1863 LONG style, exstyle;
1865 g_return_if_fail (window != NULL);
1866 g_return_if_fail (GDK_IS_WINDOW (window));
1868 style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1869 exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1871 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
1872 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
1874 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
1876 if (decorations & GDK_DECOR_ALL)
1877 style |= (WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
1878 if (decorations & GDK_DECOR_BORDER)
1879 style |= (WS_BORDER);
1880 if (decorations & GDK_DECOR_RESIZEH)
1881 style |= (WS_THICKFRAME);
1882 if (decorations & GDK_DECOR_TITLE)
1883 style |= (WS_CAPTION);
1884 if (decorations & GDK_DECOR_MENU)
1885 style |= (WS_SYSMENU);
1886 if (decorations & GDK_DECOR_MINIMIZE)
1887 style |= (WS_MINIMIZEBOX);
1888 if (decorations & GDK_DECOR_MAXIMIZE)
1889 style |= (WS_MAXIMIZEBOX);
1891 SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
1895 gdk_window_set_functions (GdkWindow *window,
1896 GdkWMFunction functions)
1898 LONG style, exstyle;
1900 g_return_if_fail (window != NULL);
1901 g_return_if_fail (GDK_IS_WINDOW (window));
1903 style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
1904 exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
1906 style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
1907 |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
1910 exstyle &= (WS_EX_TOPMOST|WS_EX_TRANSPARENT);
1912 if (functions & GDK_FUNC_ALL)
1913 style |= (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX);
1914 if (functions & GDK_FUNC_RESIZE)
1915 style |= (WS_THICKFRAME);
1916 if (functions & GDK_FUNC_MOVE)
1917 style |= (WS_THICKFRAME);
1918 if (functions & GDK_FUNC_MINIMIZE)
1919 style |= (WS_MINIMIZEBOX);
1920 if (functions & GDK_FUNC_MAXIMIZE)
1921 style |= (WS_MAXIMIZEBOX);
1923 SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
1927 * propagate the shapes from all child windows of a GDK window to the parent
1928 * window. Shamelessly ripped from Enlightenment's code
1934 QueryTree (HWND hwnd,
1944 child = GetWindow (hwnd, GW_CHILD);
1946 child = GetWindow (child, GW_HWNDNEXT);
1949 } while (child != NULL);
1953 *children = g_new (HWND, n);
1954 for (i = 0; i < n; i++)
1957 child = GetWindow (hwnd, GW_CHILD);
1959 child = GetWindow (child, GW_HWNDNEXT);
1960 *children[i] = child;
1966 gdk_propagate_shapes (HANDLE win,
1970 HRGN region, childRegion;
1975 SetRectEmpty (&emptyRect);
1976 region = CreateRectRgnIndirect (&emptyRect);
1978 GetWindowRgn (win, region);
1980 QueryTree (win, &list, &num);
1983 WINDOWPLACEMENT placement;
1985 placement.length = sizeof (WINDOWPLACEMENT);
1986 /* go through all child windows and combine regions */
1987 for (i = 0; i < num; i++)
1989 GetWindowPlacement (list[i], &placement);
1990 if (placement.showCmd = SW_SHOWNORMAL)
1992 childRegion = CreateRectRgnIndirect (&emptyRect);
1993 GetWindowRgn (list[i], childRegion);
1994 CombineRgn (region, region, childRegion, RGN_OR);
1995 DeleteObject (childRegion);
1998 SetWindowRgn (win, region, TRUE);
2001 DeleteObject (region);
2005 gdk_window_set_child_shapes (GdkWindow *window)
2007 g_return_if_fail (window != NULL);
2008 g_return_if_fail (GDK_IS_WINDOW (window));
2010 if (GDK_DRAWABLE_DESTROYED (window))
2013 gdk_propagate_shapes (GDK_DRAWABLE_XID (window), FALSE);
2017 gdk_window_merge_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), TRUE);
2028 /* Support for windows that can be guffaw-scrolled
2029 * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
2033 gdk_window_gravity_works (void)
2035 enum { UNKNOWN, NO, YES };
2036 static gint gravity_works = UNKNOWN;
2038 if (gravity_works == UNKNOWN)
2045 attr.window_type = GDK_WINDOW_TEMP;
2046 attr.wclass = GDK_INPUT_OUTPUT;
2051 attr.event_mask = 0;
2053 parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
2055 attr.window_type = GDK_WINDOW_CHILD;
2056 child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
2058 gdk_window_set_static_win_gravity (child, TRUE);
2060 gdk_window_resize (parent, 100, 110);
2061 gdk_window_move (parent, 0, -10);
2062 gdk_window_move_resize (parent, 0, 0, 100, 100);
2064 gdk_window_resize (parent, 100, 110);
2065 gdk_window_move (parent, 0, -10);
2066 gdk_window_move_resize (parent, 0, 0, 100, 100);
2068 gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
2070 gdk_window_destroy (parent);
2071 gdk_window_destroy (child);
2073 gravity_works = ((y == -20) ? YES : NO);
2076 return (gravity_works == YES);
2080 gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
2082 g_return_if_fail (window != NULL);
2084 GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
2088 gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
2090 g_return_if_fail (window != NULL);
2093 g_print ("gdk_window_set_static_win_gravity: Not implemented\n"));
2096 /*************************************************************
2097 * gdk_window_set_static_gravities:
2098 * Set the bit gravity of the given window to static,
2099 * and flag it so all children get static subwindow
2102 * window: window for which to set static gravity
2103 * use_static: Whether to turn static gravity on or off.
2105 * Does the XServer support static gravity?
2106 *************************************************************/
2109 gdk_window_set_static_gravities (GdkWindow *window,
2110 gboolean use_static)
2112 GdkWindowPrivate *private = (GdkWindowPrivate *)window;
2115 g_return_val_if_fail (window != NULL, FALSE);
2116 g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
2118 if (!use_static == !private->guffaw_gravity)
2121 if (use_static && !gdk_window_gravity_works ())
2124 private->guffaw_gravity = use_static;
2126 if (!GDK_DRAWABLE_DESTROYED (window))
2128 gdk_window_set_static_bit_gravity (window, use_static);
2130 tmp_list = private->children;
2133 gdk_window_set_static_win_gravity (window, use_static);
2135 tmp_list = tmp_list->next;