#include "config.h"
-#include "gdk.h"
-#include "gdkprivate.h"
-#include "gdkinput.h"
#include <stdlib.h>
#include <stdio.h>
+#include "gdkevents.h"
+#include "gdkpixmap.h"
+#include "gdkwindow.h"
+#include "gdkinternals.h"
+#include "gdkprivate.h"
+#include "gdkprivate-win32.h"
+#include "gdkinputprivate.h"
+#include "gdkwin32.h"
+
+static gboolean gdk_window_gravity_works (void);
+static void gdk_window_set_static_win_gravity (GdkWindow *window,
+ gboolean on);
+
/* The Win API function AdjustWindowRect may return negative values
* resulting in obscured title bars. This helper function is coreccting it.
*/
-BOOL AdjustWindowRectEx2(RECT* lpRect,
- DWORD dwStyle,
- BOOL bMenu,
- DWORD dwExStyle)
+BOOL
+SafeAdjustWindowRectEx (RECT* lpRect,
+ DWORD dwStyle,
+ BOOL bMenu,
+ DWORD dwExStyle)
{
if (!AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle))
- return FALSE;
+ {
+ WIN32_API_FAILED ("AdjustWindowRectEx");
+ return FALSE;
+ }
if (lpRect->left < 0)
{
lpRect->right -= lpRect->left;
}
return TRUE;
}
-/* HB: now use it */
-#define AdjustWindowRectEx AdjustWindowRectEx2
-/* Forward declarations */
-static gboolean gdk_window_gravity_works (void);
-static void gdk_window_set_static_win_gravity (GdkWindow *window,
- gboolean on);
+GdkDrawableClass _gdk_windowing_window_class;
-/*
- * The following fucntion by The Rasterman <raster@redhat.com>
- * This function returns the X Window ID in which the x y location is in
- * (x and y being relative to the root window), excluding any windows listed
- * in the GList excludes (this is a list of X Window ID's - gpointer being
- * the Window ID).
- *
- * This is primarily designed for internal gdk use - for DND for example
- * when using a shaped icon window as the drag object - you exclude the
- * X Window ID of the "icon" (perhaps more if excludes may be needed) and
- * You can get back an X Window ID as to what X Window ID is infact under
- * those X,Y co-ordinates.
- */
-HWND
-gdk_window_xid_at_coords (gint x,
- gint y,
- GList *excludes,
- gboolean excl_child)
+static void
+gdk_win32_window_destroy (GdkDrawable *drawable)
{
- POINT pt;
- gboolean warned = FALSE;
+ if (!GDK_DRAWABLE_DESTROYED (drawable))
+ {
+ if (GDK_DRAWABLE_TYPE (drawable) == GDK_WINDOW_FOREIGN)
+ gdk_xid_table_remove (GDK_DRAWABLE_XID (drawable));
+ else
+ g_warning ("losing last reference to undestroyed window\n");
+ }
+
+ if (GDK_WINDOW_WIN32DATA (drawable)->bg_type == GDK_WIN32_BG_PIXMAP
+ && GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap != NULL)
+ gdk_drawable_unref (GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap);
+
+ g_free (GDK_DRAWABLE_WIN32DATA (drawable));
+}
- pt.x = x;
- pt.y = y;
- /* This is probably not correct, just a quick hack */
+static GdkWindow *
+gdk_win32_window_alloc (void)
+{
+ GdkWindow *window;
+ GdkWindowPrivate *private;
+
+ static gboolean initialized = FALSE;
- if (!warned)
+ if (!initialized)
{
- g_warning ("gdk_window_xid_at_coords probably not implemented correctly");
- warned = TRUE;
+ initialized = TRUE;
+
+ _gdk_windowing_window_class = _gdk_win32_drawable_class;
+ _gdk_win32_drawable_class.destroy = gdk_win32_window_destroy;
}
- /* XXX */
- return WindowFromPoint (pt);
+ window = _gdk_window_alloc ();
+ private = (GdkWindowPrivate *) window;
+
+ private->drawable.klass = &_gdk_windowing_window_class;
+ private->drawable.klass_data = g_new (GdkWindowWin32Data, 1);
+
+ GDK_WINDOW_WIN32DATA (window)->event_mask = 0;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
+ GDK_WINDOW_WIN32DATA (window)->xcursor = NULL;
+ GDK_WINDOW_WIN32DATA (window)->hint_flags = 0;
+ GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
+
+ GDK_WINDOW_WIN32DATA (window)->input_locale = GetKeyboardLayout (0);
+ TranslateCharsetInfo ((DWORD FAR *) GetACP (),
+ &GDK_WINDOW_WIN32DATA (window)->charset_info,
+ TCI_SRCCODEPAGE);
+
+ return window;
}
void
gdk_window_init (void)
{
- unsigned int width;
- unsigned int height;
-#if 0
- width = GetSystemMetrics (SM_CXSCREEN);
- height = GetSystemMetrics (SM_CYSCREEN);
-#else
- { RECT r; /* //HB: don't obscure tray window (task bar) */
- SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
- width = r.right - r.left;
- height = r.bottom - r.top;
- }
-#endif
+ GdkWindowPrivate *private;
+ RECT r;
+ guint width;
+ guint height;
+
+ SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
+ width = r.right - r.left;
+ height = r.bottom - r.top;
+
+ gdk_parent_root = gdk_win32_window_alloc ();
+ private = (GdkWindowPrivate *) gdk_parent_root;
+
+ GDK_DRAWABLE_WIN32DATA (gdk_parent_root)->xid = gdk_root_window;
+ private->drawable.window_type = GDK_WINDOW_ROOT;
+ private->drawable.width = width;
+ private->drawable.height = height;
+
+ gdk_xid_table_insert (&gdk_root_window, gdk_parent_root);
+}
+
+/* RegisterGdkClass
+ * is a wrapper function for RegisterWindowClassEx.
+ * It creates at least one unique class for every
+ * GdkWindowType. If support for single window-specific icons
+ * is ever needed (e.g Dialog specific), every such window should
+ * get its own class
+ */
+ATOM
+RegisterGdkClass (GdkDrawableType wtype)
+{
+ static ATOM klassTOPLEVEL = 0;
+ static ATOM klassDIALOG = 0;
+ static ATOM klassCHILD = 0;
+ static ATOM klassTEMP = 0;
+ static HICON hAppIcon = NULL;
+ static WNDCLASSEX wcl;
+ ATOM klass = 0;
+
+ wcl.cbSize = sizeof(WNDCLASSEX);
+ wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
+ * on WM_SIZE and WM_MOVE. Flicker, Performance!
+ */
+ wcl.lpfnWndProc = gdk_WindowProc;
+ wcl.cbClsExtra = 0;
+ wcl.cbWndExtra = 0;
+ wcl.hInstance = gdk_ProgInstance;
+ wcl.hIcon = 0;
+ /* initialize once! */
+ if (0 == hAppIcon)
+ {
+ gchar sLoc [_MAX_PATH+1];
+ HINSTANCE hInst = GetModuleHandle(NULL);
+
+ if (0 != GetModuleFileName(hInst, sLoc, _MAX_PATH))
+ {
+ hAppIcon = ExtractIcon(hInst, sLoc, 0);
+ if (0 == hAppIcon)
+ {
+ char *gdklibname = g_strdup_printf ("gdk-%s.dll", GDK_VERSION);
+
+ hAppIcon = ExtractIcon(hInst, gdklibname, 0);
+ g_free (gdklibname);
+ }
+
+ if (0 == hAppIcon)
+ hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
+ }
+ }
+
+ wcl.lpszMenuName = NULL;
+ wcl.hIconSm = 0;
+
+ /* initialize once per class */
+#define ONCE_PER_CLASS() \
+ wcl.hIcon = CopyIcon (hAppIcon); \
+ wcl.hIconSm = CopyIcon (hAppIcon); \
+ wcl.hbrBackground = CreateSolidBrush( RGB(0,0,0)); \
+ wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
+
+ switch (wtype)
+ {
+ case GDK_WINDOW_TOPLEVEL:
+ if (0 == klassTOPLEVEL)
+ {
+ wcl.lpszClassName = "gdkWindowToplevel";
+
+ ONCE_PER_CLASS();
+ klassTOPLEVEL = RegisterClassEx(&wcl);
+ }
+ klass = klassTOPLEVEL;
+ break;
+ case GDK_WINDOW_CHILD:
+ if (0 == klassCHILD)
+ {
+ wcl.lpszClassName = "gdkWindowChild";
- gdk_root_parent.xwindow = gdk_root_window;
- gdk_root_parent.window_type = GDK_WINDOW_ROOT;
- gdk_root_parent.window.user_data = NULL;
- gdk_root_parent.width = width;
- gdk_root_parent.height = height;
- gdk_root_parent.children = NULL;
- gdk_root_parent.colormap = NULL;
- gdk_root_parent.ref_count = 1;
+ wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
+ ONCE_PER_CLASS();
+ klassCHILD = RegisterClassEx(&wcl);
+ }
+ klass = klassCHILD;
+ break;
+ case GDK_WINDOW_DIALOG:
+ if (0 == klassDIALOG)
+ {
+ wcl.lpszClassName = "gdkWindowDialog";
+ wcl.style |= CS_SAVEBITS;
+ ONCE_PER_CLASS();
+ klassDIALOG = RegisterClassEx(&wcl);
+ }
+ klass = klassDIALOG;
+ break;
+ case GDK_WINDOW_TEMP:
+ if (0 == klassTEMP)
+ {
+ wcl.lpszClassName = "gdkWindowTemp";
+ wcl.style |= CS_SAVEBITS;
+ ONCE_PER_CLASS();
+ klassTEMP = RegisterClassEx(&wcl);
+ }
+ klass = klassTEMP;
+ break;
+ case GDK_WINDOW_ROOT:
+ g_error ("cannot make windows of type GDK_WINDOW_ROOT");
+ break;
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
+ break;
+ }
- gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
+ if (klass == 0)
+ {
+ WIN32_API_FAILED ("RegisterClassEx");
+ g_error ("That is a fatal error");
+ }
+ return klass;
}
GdkWindow*
GdkVisual *visual;
HANDLE xparent;
Visual *xvisual;
-#ifdef MULTIPLE_WINDOW_CLASSES
- WNDCLASSEX wcl;
- ATOM klass;
- char wcl_name_buf[20];
- static int wcl_cnt = 0;
-#else
- static WNDCLASSEX wcl;
- static ATOM klass = 0;
-#endif
- static HICON hAppIcon = NULL;
+ ATOM klass = 0;
DWORD dwStyle, dwExStyle;
RECT rect;
int width, height;
int x, y;
char *title;
+ gint titlelen;
+ wchar_t *wctitle;
+ gint wlen;
+ char *mbtitle;
g_return_val_if_fail (attributes != NULL, NULL);
if (!parent)
- parent = (GdkWindow*) &gdk_root_parent;
+ parent = gdk_parent_root;
parent_private = (GdkWindowPrivate*) parent;
- if (parent_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (parent))
return NULL;
- xparent = parent_private->xwindow;
+ xparent = GDK_DRAWABLE_XID (parent);
- private = g_new (GdkWindowPrivate, 1);
- window = (GdkWindow*) private;
+ window = gdk_win32_window_alloc ();
+ private = (GdkWindowPrivate *)window;
private->parent = parent;
- private->destroyed = FALSE;
- private->mapped = FALSE;
- private->guffaw_gravity = FALSE;
- private->resize_count = 0;
- private->ref_count = 1;
-
- if (attributes_mask & GDK_WA_X)
- x = attributes->x;
- else
- x = 0;
-
- if (attributes_mask & GDK_WA_Y)
- y = attributes->y;
- else
- y = 0;
-
- private->x = x;
- private->y = y;
- private->width = (attributes->width > 1) ? (attributes->width) : (1);
- private->height = (attributes->height > 1) ? (attributes->height) : (1);
- private->window_type = attributes->window_type;
- private->extension_events = 0;
- private->extension_events_selected = FALSE;
+ private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
+ private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
- private->filters = NULL;
- private->children = NULL;
-
- window->user_data = NULL;
+ private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
+ private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
+ private->drawable.window_type = attributes->window_type;
+ GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
if (attributes_mask & GDK_WA_VISUAL)
visual = attributes->visual;
title = attributes->title;
else
title = g_get_prgname ();
+ if (!title)
+ title = "GDK client window";
- private->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
- private->bg_type = GDK_WIN32_BG_NORMAL;
- private->hint_flags = 0;
-
-#ifndef MULTIPLE_WINDOW_CLASSES
- if (klass == 0)
- {
-#endif
- wcl.cbSize = sizeof (WNDCLASSEX);
-#if 1
- wcl.style = CS_HREDRAW | CS_VREDRAW;
-#else
- wcl.style = 0;
-#endif
- wcl.lpfnWndProc = gdk_WindowProc;
- wcl.cbClsExtra = 0;
- wcl.cbWndExtra = 0;
- wcl.hInstance = gdk_ProgInstance;
- wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
-
-#if 0 /* tml: orig -> generates SetClassLong errors in set background */
- wcl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
- wcl.hbrBackground = NULL;
-#else
- /* initialize once! */
- if (0 == hAppIcon)
- {
- gchar sLoc [_MAX_PATH+1];
- HINSTANCE hInst = GetModuleHandle(NULL);
-
- if (0 != GetModuleFileName(hInst, sLoc, _MAX_PATH))
- {
- hAppIcon = ExtractIcon(hInst, sLoc, 0);
- if (0 == hAppIcon)
- {
- char *gdklibname = g_strdup_printf ("gdk-%s.dll", GDK_VERSION);
-
- hAppIcon = ExtractIcon(hInst, gdklibname, 0);
- g_free (gdklibname);
- }
-
- if (0 == hAppIcon)
- hAppIcon = LoadIcon (NULL, IDI_APPLICATION);
- }
- }
- wcl.hIcon = CopyIcon (hAppIcon);
- wcl.hIconSm = CopyIcon (hAppIcon);
- /* HB: starting with black to have something to release ... */
- wcl.hbrBackground = CreateSolidBrush( RGB(0,0,0));
-#endif
-
- wcl.lpszMenuName = NULL;
-#ifdef MULTIPLE_WINDOW_CLASSES
- sprintf (wcl_name_buf, "gdk-wcl-%d", wcl_cnt++);
- wcl.lpszClassName = g_strdup (wcl_name_buf);
- /* wcl.hIconSm = LoadIcon (NULL, IDI_APPLICATION); */
-#else
- wcl.lpszClassName = "GDK-window-class";
- klass = RegisterClassEx (&wcl);
- if (!klass)
- g_error ("RegisterClassEx failed");
- }
-
- private->xcursor = NULL;
-#endif
+ GDK_WINDOW_WIN32DATA (window)->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
if (parent_private && parent_private->guffaw_gravity)
{
{
dwExStyle = 0;
if (attributes_mask & GDK_WA_COLORMAP)
- private->colormap = attributes->colormap;
+ private->drawable.colormap = attributes->colormap;
else
- private->colormap = gdk_colormap_get_system ();
+ private->drawable.colormap = gdk_colormap_get_system ();
}
else
{
dwExStyle = WS_EX_TRANSPARENT;
- private->colormap = NULL;
- private->bg_type = GDK_WIN32_BG_TRANSPARENT;
- private->bg_pixmap = NULL;
+ private->drawable.colormap = NULL;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_TRANSPARENT;
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
}
if (attributes_mask & GDK_WA_X)
if (parent_private)
parent_private->children = g_list_prepend (parent_private->children, window);
- switch (private->window_type)
+ switch (private->drawable.window_type)
{
case GDK_WINDOW_TOPLEVEL:
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
break;
case GDK_WINDOW_DIALOG:
dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
+#if 0
+ dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
+#endif
xparent = gdk_root_window;
break;
case GDK_WINDOW_TEMP:
dwStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
-#ifdef MULTIPLE_WINDOW_CLASSES
- wcl.style |= CS_SAVEBITS;
-#endif
dwExStyle |= WS_EX_TOOLWINDOW;
break;
case GDK_WINDOW_ROOT:
g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
break;
}
-#ifdef MULTIPLE_WINDOW_CLASSES
- klass = RegisterClassEx (&wcl);
- if (!klass)
- g_error ("RegisterClassEx failed");
-#endif
+ klass = RegisterGdkClass (private->drawable.window_type);
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
if (x == CW_USEDEFAULT)
{
rect.top = y;
}
- rect.right = rect.left + private->width;
- rect.bottom = rect.top + private->height;
+ rect.right = rect.left + private->drawable.width;
+ rect.bottom = rect.top + private->drawable.height;
- if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
- g_warning ("gdk_window_new: AdjustWindowRectEx failed");
+ SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
if (x != CW_USEDEFAULT)
{
}
else
{
- width = private->width;
- height = private->height;
+ width = private->drawable.width;
+ height = private->drawable.height;
}
- private->xwindow =
+ titlelen = strlen (title);
+ wctitle = g_new (wchar_t, titlelen + 1);
+ mbtitle = g_new (char, 3*titlelen + 1);
+ wlen = gdk_nmbstowchar_ts (wctitle, title, titlelen, titlelen);
+ wctitle[wlen] = 0;
+ WideCharToMultiByte (GetACP (), 0, wctitle, -1,
+ mbtitle, 3*titlelen, NULL, NULL);
+
+ GDK_DRAWABLE_WIN32DATA (window)->xid =
CreateWindowEx (dwExStyle,
- wcl.lpszClassName,
- title,
+ MAKEINTRESOURCE(klass),
+ mbtitle,
dwStyle,
x, y,
width, height,
NULL,
gdk_ProgInstance,
NULL);
+
GDK_NOTE (MISC,
- g_print ("gdk_window_create: %s %s %#x %dx%d@+%d+%d %#x = %#x\n",
- (private->window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
- (private->window_type == GDK_WINDOW_CHILD ? "CHILD" :
- (private->window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
- (private->window_type == GDK_WINDOW_TEMP ? "TEMP" :
+ g_print ("gdk_window_new: %s %s %dx%d@+%d+%d %#x = %#x\n"
+ "...locale %#x codepage %d\n",
+ (private->drawable.window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
+ (private->drawable.window_type == GDK_WINDOW_CHILD ? "CHILD" :
+ (private->drawable.window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
+ (private->drawable.window_type == GDK_WINDOW_TEMP ? "TEMP" :
"???")))),
- title,
- dwStyle,
+ mbtitle,
width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
xparent,
- private->xwindow));
+ GDK_DRAWABLE_XID (window),
+ GDK_WINDOW_WIN32DATA (window)->input_locale,
+ GDK_WINDOW_WIN32DATA (window)->charset_info.ciACP));
+
+ g_free (mbtitle);
+ g_free (wctitle);
- gdk_window_ref (window);
- gdk_xid_table_insert (&private->xwindow, window);
+ if (GDK_DRAWABLE_XID (window) == NULL)
+ {
+ WIN32_API_FAILED ("CreateWindowEx");
+ g_free (GDK_DRAWABLE_WIN32DATA (window));
+ g_free (private);
+ return NULL;
+ }
- if (private->colormap)
- gdk_colormap_ref (private->colormap);
+ gdk_drawable_ref (window);
+ gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
+
+ if (private->drawable.colormap)
+ gdk_colormap_ref (private->drawable.colormap);
gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
(attributes->cursor) :
RECT rect;
POINT point;
- private = g_new (GdkWindowPrivate, 1);
- window = (GdkWindow*) private;
+ window = gdk_win32_window_alloc ();
+ private = (GdkWindowPrivate *)window;
parent = GetParent ((HWND) anid);
private->parent = gdk_xid_table_lookup (parent);
if (parent_private)
parent_private->children = g_list_prepend (parent_private->children, window);
- private->xwindow = (HWND) anid;
+ GDK_DRAWABLE_WIN32DATA (window)->xid = (HWND) anid;
GetClientRect ((HWND) anid, &rect);
point.x = rect.left;
point.y = rect.right;
ClientToScreen ((HWND) anid, &point);
- if (parent != HWND_DESKTOP)
+ if (parent != GetDesktopWindow ())
ScreenToClient (parent, &point);
private->x = point.x;
private->y = point.y;
- private->width = rect.right - rect.left;
- private->height = rect.bottom - rect.top;
- private->resize_count = 0;
- private->ref_count = 1;
- private->window_type = GDK_WINDOW_FOREIGN;
- private->destroyed = FALSE;
- private->mapped = IsWindowVisible (private->xwindow);
- private->guffaw_gravity = FALSE;
- private->extension_events = 0;
- private->extension_events_selected = FALSE;
-
- private->colormap = NULL;
+ private->drawable.width = rect.right - rect.left;
+ private->drawable.height = rect.bottom - rect.top;
+ private->drawable.window_type = GDK_WINDOW_FOREIGN;
+ private->drawable.destroyed = FALSE;
+ private->mapped = IsWindowVisible (GDK_DRAWABLE_XID (window));
- private->filters = NULL;
- private->children = NULL;
+ private->drawable.colormap = NULL;
- window->user_data = NULL;
-
- gdk_window_ref (window);
- gdk_xid_table_insert (&private->xwindow, window);
+ gdk_drawable_ref (window);
+ gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
return window;
}
/* Call this function when you want a window and all its children to
- * disappear. When xdestroy is true, a request to destroy the XWindow
- * is sent out. When it is false, it is assumed that the XWindow has
+ * disappear. When xdestroy is true, a request to destroy the window
+ * is sent out. When it is false, it is assumed that the window has
* been or will be destroyed by destroying some ancestor of this
* window.
*/
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
+ private = (GdkWindowPrivate *) window;
GDK_NOTE (MISC, g_print ("gdk_window_internal_destroy %#x\n",
- private->xwindow));
+ GDK_DRAWABLE_XID (window)));
- switch (private->window_type)
+ switch (GDK_DRAWABLE_TYPE (window))
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
case GDK_WINDOW_DIALOG:
case GDK_WINDOW_TEMP:
case GDK_WINDOW_FOREIGN:
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
if (private->parent)
{
parent_private->children = g_list_remove (parent_private->children, window);
}
- if (private->window_type != GDK_WINDOW_FOREIGN)
+ if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
{
children = tmp = private->children;
private->children = NULL;
private->filters = NULL;
}
- if (private->window_type == GDK_WINDOW_FOREIGN)
+ if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
{
if (our_destroy && (private->parent != NULL))
{
* OTOH, I don't think foreign windows are much
* used, so the question is maybe academic.
*/
- PostMessage (private->xwindow, WM_QUIT, 0, 0);
+ PostMessage (GDK_DRAWABLE_XID (window), WM_QUIT, 0, 0);
}
}
else if (xdestroy)
- DestroyWindow (private->xwindow);
+ DestroyWindow (GDK_DRAWABLE_XID (window));
- if (private->colormap)
- gdk_colormap_unref (private->colormap);
+ if (private->drawable.colormap)
+ gdk_colormap_unref (private->drawable.colormap);
private->mapped = FALSE;
- private->destroyed = TRUE;
+ private->drawable.destroyed = TRUE;
}
break;
g_error ("attempted to destroy root window");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("called gdk_window_destroy on a pixmap (use gdk_drawable_unref)");
break;
}
}
gdk_window_destroy (GdkWindow *window)
{
gdk_window_internal_destroy (window, TRUE, TRUE);
- gdk_window_unref (window);
+ gdk_drawable_unref (window);
}
-/* This function is called when the XWindow is really gone. */
+/* This function is called when the window really gone. */
void
gdk_window_destroy_notify (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
-
- GDK_NOTE (EVENTS, g_print ("gdk_window_destroy_notify: %#x %d\n",
- private->xwindow, private->destroyed));
-
- if (!private->destroyed)
- {
- if (private->window_type == GDK_WINDOW_FOREIGN)
- gdk_window_internal_destroy (window, FALSE, FALSE);
- else
- g_warning ("GdkWindow %#lx unexpectedly destroyed", private->xwindow);
- }
-
- gdk_xid_table_remove (private->xwindow);
- gdk_window_unref (window);
-}
-
-GdkWindow*
-gdk_window_ref (GdkWindow *window)
-{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- g_return_val_if_fail (window != NULL, NULL);
-
- private->ref_count += 1;
-
- GDK_NOTE (MISC, g_print ("gdk_window_ref %#x %d\n",
- private->xwindow, private->ref_count));
-
- return window;
-}
-
-void
-gdk_window_unref (GdkWindow *window)
-{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_if_fail (window != NULL);
- private->ref_count -= 1;
+ GDK_NOTE (EVENTS,
+ g_print ("gdk_window_destroy_notify: %#x %s\n",
+ GDK_DRAWABLE_XID (window),
+ (GDK_DRAWABLE_DESTROYED (window) ? "yes" : "no")));
- GDK_NOTE (MISC, g_print ("gdk_window_unref %#x %d%s\n",
- private->xwindow, private->ref_count,
- (private->ref_count == 0 ? " freeing" : "")));
-
- if (private->ref_count == 0)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (private->bg_type == GDK_WIN32_BG_PIXMAP && private->bg_pixmap != NULL)
- gdk_pixmap_unref (private->bg_pixmap);
+ if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
+ g_warning ("window %#x unexpectedly destroyed",
+ GDK_DRAWABLE_XID (window));
- if (!private->destroyed)
- {
- if (private->window_type == GDK_WINDOW_FOREIGN)
- gdk_xid_table_remove (private->xwindow);
- else
- g_warning ("losing last reference to undestroyed window");
- }
- g_dataset_destroy (window);
- g_free (window);
+ gdk_window_internal_destroy (window, FALSE, FALSE);
}
+
+ gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
+ gdk_drawable_unref (window);
}
void
gdk_window_show (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- private->mapped = TRUE;
- if (private->window_type == GDK_WINDOW_TEMP)
+ ((GdkWindowPrivate *) window)->mapped = TRUE;
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TEMP)
{
- ShowWindow (private->xwindow, SW_SHOWNOACTIVATE);
- SetWindowPos (private->xwindow, HWND_TOPMOST, 0, 0, 0, 0,
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNOACTIVATE);
+ SetWindowPos (GDK_DRAWABLE_XID (window), HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
#if 0
- ShowWindow (private->xwindow, SW_HIDE); /* Don't put on toolbar */
+ /* Don't put on toolbar */
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
#endif
}
else
{
- ShowWindow (private->xwindow, SW_SHOWNORMAL);
- ShowWindow (private->xwindow, SW_RESTORE);
- SetForegroundWindow (private->xwindow);
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNORMAL);
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_RESTORE);
+ SetForegroundWindow (GDK_DRAWABLE_XID (window));
+ BringWindowToTop (GDK_DRAWABLE_XID (window));
#if 0
- ShowOwnedPopups (private->xwindow, TRUE);
+ ShowOwnedPopups (GDK_DRAWABLE_XID (window), TRUE);
#endif
}
}
void
gdk_window_hide (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- private->mapped = FALSE;
- if (private->window_type == GDK_WINDOW_TOPLEVEL)
- ShowOwnedPopups (private->xwindow, FALSE);
+ ((GdkWindowPrivate *) window)->mapped = FALSE;
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
+ ShowOwnedPopups (GDK_DRAWABLE_XID (window), FALSE);
#if 1
- ShowWindow (private->xwindow, SW_HIDE);
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
#elif 0
- ShowWindow (private->xwindow, SW_MINIMIZE);
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_MINIMIZE);
#else
- CloseWindow (private->xwindow);
+ CloseWindow (GDK_DRAWABLE_XID (window));
#endif
}
}
void
gdk_window_withdraw (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
+ GDK_DRAWABLE_XID (window)));
gdk_window_hide (window); /* XXX */
}
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
- DWORD dwStyle;
- DWORD dwExStyle;
GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
- private->xwindow, x, y));
- GetClientRect (private->xwindow, &rect);
+ GDK_DRAWABLE_XID (window), x, y));
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
- if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
- g_warning ("gdk_window_move: AdjustWindowRectEx failed");
- if (private->window_type == GDK_WINDOW_CHILD)
+ private = (GdkWindowPrivate *) window;
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
+
+ if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
+ {
+ POINT ptTL, ptBR;
+ DWORD dwStyle;
+ DWORD dwExStyle;
+
+ ptTL.x = 0;
+ ptTL.y = 0;
+ ClientToScreen (GDK_DRAWABLE_XID (window), &ptTL);
+ rect.left = x;
+ rect.top = y;
+
+ ptBR.x = rect.right;
+ ptBR.y = rect.bottom;
+ ClientToScreen (GDK_DRAWABLE_XID (window), &ptBR);
+ rect.right = x + ptBR.x - ptTL.x;
+ rect.bottom = y + ptBR.y - ptTL.y;
+
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
+ SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
+
+ x = rect.left;
+ y = rect.top;
+ }
+ else
{
private->x = x;
private->y = y;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
+ GDK_DRAWABLE_XID (window),
rect.right - rect.left, rect.bottom - rect.top,
- x + rect.left, y + rect.top));
- if (!MoveWindow (private->xwindow,
- x + rect.left, y + rect.top,
- rect.right - rect.left, rect.bottom - rect.top,
+ x, y));
+ if (!MoveWindow (GDK_DRAWABLE_XID (window),
+ x, y, rect.right - rect.left, rect.bottom - rect.top,
TRUE))
- g_warning ("gdk_window_move: MoveWindow failed");
+ WIN32_API_FAILED ("MoveWindow");
}
}
private = (GdkWindowPrivate*) window;
- if (!private->destroyed &&
+ if (!private->drawable.destroyed &&
((private->resize_count > 0) ||
- (private->width != (guint16) width) ||
- (private->height != (guint16) height)))
+ (private->drawable.width != (guint16) width) ||
+ (private->drawable.height != (guint16) height)))
{
- RECT rect;
- POINT pt;
- DWORD dwStyle;
- DWORD dwExStyle;
int x, y;
GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
- private->xwindow, width, height));
+ GDK_DRAWABLE_XID (window), width, height));
- pt.x = 0;
- pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
- rect.left = pt.x;
- rect.top = pt.y;
- rect.right = pt.x + width;
- rect.bottom = pt.y + height;
-
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
- if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
- g_warning ("gdk_window_resize: AdjustWindowRectEx failed");
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
+ POINT pt;
+ RECT rect;
+ DWORD dwStyle;
+ DWORD dwExStyle;
+
+ pt.x = 0;
+ pt.y = 0;
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ rect.left = pt.x;
+ rect.top = pt.y;
+ rect.right = pt.x + width;
+ rect.bottom = pt.y + height;
+
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
+ if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
+ WIN32_API_FAILED ("AdjustWindowRectEx");
+
x = rect.left;
y = rect.top;
+ width = rect.right - rect.left;
+ height = rect.bottom - rect.top;
}
else
{
x = private->x;
y = private->y;
+ private->drawable.width = width;
+ private->drawable.height = height;
}
private->resize_count += 1;
- if (private->window_type == GDK_WINDOW_CHILD)
- {
- private->width = width;
- private->height = height;
- }
- GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
- rect.right - rect.left, rect.bottom - rect.top,
- x, y));
- if (!MoveWindow (private->xwindow,
- x, y,
- rect.right - rect.left, rect.bottom - rect.top,
+ GDK_NOTE (MISC,
+ g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
+ GDK_DRAWABLE_XID (window), width, height, x, y));
+ if (!MoveWindow (GDK_DRAWABLE_XID (window),
+ x, y, width, height,
TRUE))
- g_warning ("gdk_window_resize: MoveWindow failed");
+ WIN32_API_FAILED ("MoveWindow");
}
}
if ((gint16) height < 1)
height = 1;
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
DWORD dwStyle;
DWORD dwExStyle;
GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
+ GDK_DRAWABLE_XID (window), width, height, x, y));
+ private = (GdkWindowPrivate*) window;
rect.left = x;
rect.top = y;
rect.right = x + width;
rect.bottom = y + height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
- g_warning ("gdk_window_move_resize: AdjustWindowRectEx failed");
+ WIN32_API_FAILED ("AdjustWindowRectEx");
- if (private->window_type == GDK_WINDOW_CHILD)
+ if (private->drawable.window_type == GDK_WINDOW_CHILD)
{
private->x = x;
private->y = y;
- private->width = width;
- private->height = height;
+ private->drawable.width = width;
+ private->drawable.height = height;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
+ GDK_DRAWABLE_XID (window),
rect.right - rect.left, rect.bottom - rect.top,
rect.left, rect.top));
- if (!MoveWindow (private->xwindow,
+ if (!MoveWindow (GDK_DRAWABLE_XID (window),
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
TRUE))
- g_warning ("gdk_window_move_resize: MoveWindow failed");
+ WIN32_API_FAILED ("MoveWindow");
if (private->guffaw_gravity)
{
g_return_if_fail (window != NULL);
if (!new_parent)
- new_parent = (GdkWindow*) &gdk_root_parent;
+ new_parent = gdk_parent_root;
window_private = (GdkWindowPrivate*) window;
- old_parent_private = (GdkWindowPrivate*)window_private->parent;
+ old_parent_private = (GdkWindowPrivate *) window_private->parent;
parent_private = (GdkWindowPrivate*) new_parent;
- if (!window_private->destroyed && !parent_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window)
+ && !GDK_DRAWABLE_DESTROYED (new_parent))
{
GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
- window_private->xwindow,
- parent_private->xwindow));
- if (!SetParent (window_private->xwindow, parent_private->xwindow))
- g_warning ("gdk_window_reparent: SetParent failed");
+ GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (new_parent)));
+ if (!SetParent (GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (new_parent)))
+ WIN32_API_FAILED ("SetParent");
- if (!MoveWindow (window_private->xwindow,
+ if (!MoveWindow (GDK_DRAWABLE_XID (window),
x, y,
- window_private->width, window_private->height,
+ window_private->drawable.width,
+ window_private->drawable.height,
TRUE))
- g_warning ("gdk_window_reparent: MoveWindow failed");
+ WIN32_API_FAILED ("MoveWindow");
}
window_private->parent = new_parent;
if (old_parent_private)
- old_parent_private->children = g_list_remove (old_parent_private->children, window);
+ old_parent_private->children =
+ g_list_remove (old_parent_private->children, window);
if ((old_parent_private &&
(!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
void
gdk_window_clear (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
- {
- gdk_window_clear_area (window, 0, 0, private->width, private->height);
- }
+ if (!GDK_DRAWABLE_DESTROYED (window))
+ gdk_window_clear_area (window, 0, 0, 0, 0);
}
void
-gdk_window_clear_area (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+_gdk_windowing_window_clear_area (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
HDC hdc;
- if (width == -1)
- width = G_MAXSHORT/2; /* Yeah, right */
- if (height == -1)
- height = G_MAXSHORT/2;
- GDK_NOTE (MISC, g_print ("gdk_window_clear_area: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
- hdc = GetDC (private->xwindow);
- IntersectClipRect (hdc, x, y, x + width, y + height);
- SendMessage (private->xwindow, WM_ERASEBKGND, (WPARAM) hdc, 0);
- ReleaseDC (private->xwindow, hdc);
+ if (width == 0)
+ width = ((GdkDrawablePrivate *) window)->width - x;
+ if (height == 0)
+ height = ((GdkDrawablePrivate *) window)->height - y;
+ GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area: "
+ "%#x %dx%d@+%d+%d\n",
+ GDK_DRAWABLE_XID (window), width, height, x, y));
+ hdc = GetDC (GDK_DRAWABLE_XID (window));
+ IntersectClipRect (hdc, x, y, x + width + 1, y + height + 1);
+ SendMessage (GDK_DRAWABLE_XID (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
}
void
-gdk_window_clear_area_e (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+_gdk_windowing_window_clear_area_e (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
- GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
+ GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area_e: "
+ "%#x %dx%d@+%d+%d\n",
+ GDK_DRAWABLE_XID (window), width, height, x, y));
rect.left = x;
- rect.right = x + width;
+ rect.right = x + width + 1;
rect.top = y;
- rect.bottom = y + height;
- if (!InvalidateRect (private->xwindow, &rect, TRUE))
- g_warning ("gdk_window_clear_area_e: InvalidateRect failed");
- UpdateWindow (private->xwindow);
- }
-}
-
-void
-gdk_window_copy_area (GdkWindow *window,
- GdkGC *gc,
- gint x,
- gint y,
- GdkWindow *source_window,
- gint source_x,
- gint source_y,
- gint width,
- gint height)
-{
- GdkWindowPrivate *src_private;
- GdkWindowPrivate *dest_private;
- GdkGCPrivate *gc_private;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (gc != NULL);
-
- if (source_window == NULL)
- source_window = window;
-
- src_private = (GdkWindowPrivate*) source_window;
- dest_private = (GdkWindowPrivate*) window;
- gc_private = (GdkGCPrivate*) gc;
-
- if (!src_private->destroyed && !dest_private->destroyed)
- {
- HDC hdcDest, hdcSrc;
-
- if ((hdcDest = GetDC (dest_private->xwindow)) == NULL)
- g_warning ("gdk_window_copy_area: GetDC failed");
-
- if ((hdcSrc = GetDC (src_private->xwindow)) == NULL)
- g_warning ("gdk_window_copy_area: GetDC failed");
-
- if (!BitBlt (hdcDest, x, y, width, height, hdcSrc, source_x, source_y, SRCCOPY))
- g_warning ("gdk_window_copy_area: BitBlt failed");
-
- ReleaseDC (dest_private->xwindow, hdcDest);
- ReleaseDC (src_private->xwindow, hdcSrc);
+ rect.bottom = y + height + 1;
+ if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
+ WIN32_GDI_FAILED ("InvalidateRect");
+ UpdateWindow (GDK_DRAWABLE_XID (window));
}
}
void
gdk_window_raise (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- if (!BringWindowToTop (private->xwindow))
- g_warning ("gdk_window_raise: BringWindowToTop failed");
+ if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
+ WIN32_API_FAILED ("BringWindowToTop");
}
}
void
gdk_window_lower (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- if (!SetWindowPos (private->xwindow, HWND_BOTTOM, 0, 0, 0, 0,
+ if (!SetWindowPos (GDK_DRAWABLE_XID (window), HWND_BOTTOM, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
- g_warning ("gdk_window_lower: SetWindowPos failed");
+ WIN32_API_FAILED ("SetWindowPos");
}
}
-void
-gdk_window_set_user_data (GdkWindow *window,
- gpointer user_data)
-{
- g_return_if_fail (window != NULL);
-
- window->user_data = user_data;
-}
-
void
gdk_window_set_hints (GdkWindow *window,
gint x,
gint max_height,
gint flags)
{
- GdkWindowPrivate *private;
WINDOWPLACEMENT size_hints;
RECT rect;
DWORD dwStyle;
int diff;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
- private->xwindow,
+ GDK_DRAWABLE_XID (window),
min_width, min_height, max_width, max_height,
x, y));
- private->hint_flags = flags;
+ GDK_WINDOW_WIN32DATA (window)->hint_flags = flags;
size_hints.length = sizeof (size_hints);
if (flags)
{
if (flags & GDK_HINT_POS)
- if (!GetWindowPlacement (private->xwindow, &size_hints))
- g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
+ if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+ WIN32_API_FAILED ("GetWindowPlacement");
else
{
GDK_NOTE (MISC, g_print ("...rcNormalPosition:"
rect.top = y;
rect.right = rect.left + 200; /* dummy */
rect.bottom = rect.top + 200;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
size_hints.flags = 0;
size_hints.showCmd = SW_SHOWNA;
size_hints.rcNormalPosition.top,
size_hints.rcNormalPosition.right,
size_hints.rcNormalPosition.bottom));
- if (!SetWindowPlacement (private->xwindow, &size_hints))
- g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
- private->hint_x = rect.left;
- private->hint_y = rect.top;
+ if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+ WIN32_API_FAILED ("SetWindowPlacement");
+ GDK_WINDOW_WIN32DATA (window)->hint_x = rect.left;
+ GDK_WINDOW_WIN32DATA (window)->hint_y = rect.top;
}
if (flags & GDK_HINT_MIN_SIZE)
rect.top = 0;
rect.right = min_width;
rect.bottom = min_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
- private->hint_min_width = rect.right - rect.left;
- private->hint_min_height = rect.bottom - rect.top;
+ GDK_WINDOW_WIN32DATA (window)->hint_min_width =
+ rect.right - rect.left;
+ GDK_WINDOW_WIN32DATA (window)->hint_min_height =
+ rect.bottom - rect.top;
/* Also chek if he current size of the window is in bounds. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
if (rect.right < min_width && rect.bottom < min_height)
gdk_window_resize (window, min_width, min_height);
else if (rect.right < min_width)
else if (rect.bottom < min_height)
gdk_window_resize (window, rect.right, min_height);
}
+
if (flags & GDK_HINT_MAX_SIZE)
{
rect.left = 0;
rect.top = 0;
rect.right = max_width;
rect.bottom = max_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
- private->hint_max_width = rect.right - rect.left;
- private->hint_max_height = rect.bottom - rect.top;
+ GDK_WINDOW_WIN32DATA (window)->hint_max_width =
+ rect.right - rect.left;
+ GDK_WINDOW_WIN32DATA (window)->hint_max_height =
+ rect.bottom - rect.top;
/* Again, check if the window is too large currently. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
if (rect.right > max_width && rect.bottom > max_height)
gdk_window_resize (window, max_width, max_height);
else if (rect.right > max_width)
GdkGeometry *geometry,
GdkWindowHints geom_mask)
{
- GdkWindowPrivate *private;
WINDOWPLACEMENT size_hints;
RECT rect;
DWORD dwStyle;
int diff;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
-
+
size_hints.length = sizeof (size_hints);
- private->hint_flags = geom_mask;
+ GDK_WINDOW_WIN32DATA (window)->hint_flags = geom_mask;
if (geom_mask & GDK_HINT_POS)
; /* XXX */
rect.top = 0;
rect.right = geometry->min_width;
rect.bottom = geometry->min_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
- private->hint_min_width = rect.right - rect.left;
- private->hint_min_height = rect.bottom - rect.top;
+ GDK_WINDOW_WIN32DATA (window)->hint_min_width = rect.right - rect.left;
+ GDK_WINDOW_WIN32DATA (window)->hint_min_height = rect.bottom - rect.top;
/* Also check if he current size of the window is in bounds */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
if (rect.right < geometry->min_width
&& rect.bottom < geometry->min_height)
gdk_window_resize (window, geometry->min_width, geometry->min_height);
rect.top = 0;
rect.right = geometry->max_width;
rect.bottom = geometry->max_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
- private->hint_max_width = rect.right - rect.left;
- private->hint_max_height = rect.bottom - rect.top;
+ GDK_WINDOW_WIN32DATA (window)->hint_max_width = rect.right - rect.left;
+ GDK_WINDOW_WIN32DATA (window)->hint_max_height = rect.bottom - rect.top;
/* Again, check if the window is too large currently. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
if (rect.right > geometry->max_width
&& rect.bottom > geometry->max_height)
gdk_window_resize (window, geometry->max_width, geometry->max_height);
if (geom_mask & GDK_HINT_BASE_SIZE
&& geometry->base_width > 0
&& geometry->base_height > 0)
- if (!GetWindowPlacement (private->xwindow, &size_hints))
- g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
+ if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+ WIN32_API_FAILED ("GetWindowPlacement");
else
{
GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
size_hints.rcNormalPosition.top,
size_hints.rcNormalPosition.right,
size_hints.rcNormalPosition.bottom));
- if (!SetWindowPlacement (private->xwindow, &size_hints))
- g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
+ if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+ WIN32_API_FAILED ("SetWindowPlacement");
}
if (geom_mask & GDK_HINT_RESIZE_INC)
gdk_window_set_title (GdkWindow *window,
const gchar *title)
{
- GdkWindowPrivate *private;
-
+ gint titlelen;
+ wchar_t *wcstr;
+ gint wlen;
+ char *mbstr;
+
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (title != NULL);
+ g_return_if_fail (strlen (title) > 0);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
+ GDK_DRAWABLE_XID (window), title));
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (!SetWindowText (private->xwindow, title))
- g_warning ("gdk_window_set_title: SetWindowText failed");
+ /* As the title is in UTF-8 we must translate it
+ * to the system codepage.
+ */
+ titlelen = strlen (title);
+ wcstr = g_new (wchar_t, titlelen + 1);
+ mbstr = g_new (char, 3*titlelen + 1);
+ wlen = gdk_nmbstowchar_ts (wcstr, title, titlelen, titlelen);
+ wcstr[wlen] = 0;
+ WideCharToMultiByte (GetACP (), 0, wcstr, -1,
+ mbstr, 3*titlelen, NULL, NULL);
+
+ if (!SetWindowText (GDK_DRAWABLE_XID (window), mbstr))
+ WIN32_API_FAILED ("SetWindowText");
+
+ g_free (mbstr);
+ g_free (wcstr);
}
}
gdk_window_set_role (GdkWindow *window,
const gchar *role)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_role: %#x %s\n",
- private->xwindow, (role ? role : "NULL")));
+ GDK_DRAWABLE_XID (window), (role ? role : "NULL")));
/* XXX */
}
gdk_window_set_transient_for (GdkWindow *window,
GdkWindow *parent)
{
- GdkWindowPrivate *private;
- GdkWindowPrivate *parent_private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- parent_private = (GdkWindowPrivate*) parent;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %#x %#x\n",
- private->xwindow, parent_private->xwindow));
+ GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (parent)));
/* XXX */
}
gdk_window_set_background (GdkWindow *window,
GdkColor *color)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) private->colormap;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
- private->xwindow,
+ GDK_DRAWABLE_XID (window),
gdk_color_to_string (color)));
- if (private->bg_type == GDK_WIN32_BG_PIXMAP)
- {
- if (private->bg_pixmap != NULL)
- {
- gdk_pixmap_unref (private->bg_pixmap);
- private->bg_pixmap = NULL;
- }
- private->bg_type = GDK_WIN32_BG_NORMAL;
- }
-#ifdef MULTIPLE_WINDOW_CLASSES
- if (colormap_private != NULL
- && colormap_private->xcolormap->rc_palette)
- {
- /* If we are on a palettized display we can't use the window
- * class background brush, but must handle WM_ERASEBKGND.
- * At least, I think so.
- */
-#endif
- private->bg_type = GDK_WIN32_BG_PIXEL;
- private->bg_pixel = *color;
-#ifdef MULTIPLE_WINDOW_CLASSES
- }
- else
+ if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
{
- /* Non-palettized display; just set the window class background
- brush. */
- HBRUSH hbr;
- HGDIOBJ oldbrush;
- COLORREF background;
-
- background = RGB (color->red >> 8,
- color->green >> 8,
- color->blue >> 8);
-
- if ((hbr = CreateSolidBrush (GetNearestColor (gdk_DC,
- background))) == NULL)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
{
- g_warning ("gdk_window_set_background: CreateSolidBrush failed");
- return;
+ gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
}
-
- oldbrush = (HGDIOBJ) GetClassLong (private->xwindow,
- GCL_HBRBACKGROUND);
-
- if (SetClassLong (private->xwindow, GCL_HBRBACKGROUND,
- (LONG) hbr) == 0)
- g_warning ("gdk_window_set_background: SetClassLong failed");
-
- if (!DeleteObject (oldbrush))
- g_warning ("gdk_window_set_background: DeleteObject failed");
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
}
-#endif
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXEL;
+ GDK_WINDOW_WIN32DATA (window)->bg_pixel = color->pixel;
}
}
GdkPixmap *pixmap,
gint parent_relative)
{
- GdkWindowPrivate *window_private;
-#ifdef MULTIPLE_WINDOW_CLASSES
- GdkPixmapPrivate *pixmap_private;
-#endif
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
-#ifdef MULTIPLE_WINDOW_CLASSES
- pixmap_private = (GdkPixmapPrivate*) pixmap;
-#endif
-
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
- if (window_private->bg_type == GDK_WIN32_BG_PIXMAP)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
{
- if (window_private->bg_pixmap != NULL)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
{
- gdk_pixmap_unref (window_private->bg_pixmap);
- window_private->bg_pixmap = NULL;
+ gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
}
- window_private->bg_type = GDK_WIN32_BG_NORMAL;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
}
if (parent_relative)
{
- window_private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
+ GDK_WINDOW_WIN32DATA (window)->bg_type =
+ GDK_WIN32_BG_PARENT_RELATIVE;
}
else if (!pixmap)
{
-#ifdef MULTIPLE_WINDOW_CLASSES
- SetClassLong (window_private->xwindow, GCL_HBRBACKGROUND,
- (LONG) GetStockObject (BLACK_BRUSH));
-#endif
- }
-#ifdef MULTIPLE_WINDOW_CLASSES
- else if (colormap_private->xcolormap->rc_palette)
- {
- /* Must do the background painting in the
- * WM_ERASEBKGND handler.
- */
- window_private->bg_type = GDK_WIN32_BG_PIXMAP;
- window_private->bg_pixmap = pixmap;
- gdk_pixmap_ref (pixmap);
- }
- else if (pixmap_private->width <= 8
- && pixmap_private->height <= 8)
- {
- /* We can use small pixmaps directly as background brush */
- SetClassLong (window_private->xwindow, GCL_HBRBACKGROUND,
- (LONG) CreatePatternBrush (pixmap_private->xwindow));
+
}
-#endif
else
{
- /* We must cache the pixmap in the WindowPrivate and
+ /* We must cache the pixmap in the GdkWindowWin32Data and
* paint it each time we get WM_ERASEBKGND
*/
- window_private->bg_type = GDK_WIN32_BG_PIXMAP;
- window_private->bg_pixmap = pixmap;
- gdk_pixmap_ref (pixmap);
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXMAP;
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = pixmap;
+ gdk_drawable_ref (pixmap);
}
}
}
gdk_window_set_cursor (GdkWindow *window,
GdkCursor *cursor)
{
- GdkWindowPrivate *window_private;
GdkCursorPrivate *cursor_private;
HCURSOR xcursor;
+ POINT pt;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
cursor_private = (GdkCursorPrivate*) cursor;
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
if (!cursor)
xcursor = LoadCursor (NULL, IDC_ARROW);
xcursor = cursor_private->xcursor;
GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
- window_private->xwindow, xcursor));
-#ifdef MULTIPLE_WINDOW_CLASSES
- if (!SetClassLong (window_private->xwindow, GCL_HCURSOR, (LONG) xcursor))
- g_warning ("gdk_window_set_cursor: SetClassLong failed");
-#else
- window_private->xcursor = xcursor;
-#endif
- SetCursor (xcursor);
- }
-}
+ GDK_DRAWABLE_XID (window), xcursor));
+ GDK_WINDOW_WIN32DATA (window)->xcursor = xcursor;
-void
-gdk_window_set_colormap (GdkWindow *window,
- GdkColormap *colormap)
-{
- GdkWindowPrivate *window_private;
- GdkColormapPrivate *colormap_private;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (colormap != NULL);
-
- window_private = (GdkWindowPrivate*) window;
- colormap_private = (GdkColormapPrivate*) colormap;
-
- if (!window_private->destroyed)
- {
- /* XXX ??? */
- GDK_NOTE (MISC, g_print ("gdk_window_set_colormap: %#x %#x\n",
- window_private->xwindow,
- colormap_private->xcolormap));
- if (window_private->colormap)
- gdk_colormap_unref (window_private->colormap);
- window_private->colormap = colormap;
- gdk_colormap_ref (window_private->colormap);
-
- if (window_private->window_type != GDK_WINDOW_TOPLEVEL)
- gdk_window_add_colormap_windows (window);
+ GetCursorPos (&pt);
+ if (ChildWindowFromPoint (GDK_DRAWABLE_XID (window), pt) == GDK_DRAWABLE_XID (window))
+ SetCursor (xcursor);
}
}
-void
-gdk_window_get_user_data (GdkWindow *window,
- gpointer *data)
-{
- g_return_if_fail (window != NULL);
-
- *data = window->user_data;
-}
-
void
gdk_window_get_geometry (GdkWindow *window,
gint *x,
gint *height,
gint *depth)
{
- GdkWindowPrivate *window_private;
+ g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
if (!window)
- window = (GdkWindow*) &gdk_root_parent;
-
- window_private = (GdkWindowPrivate*) window;
+ window = gdk_parent_root;
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
- if (!GetClientRect (window_private->xwindow, &rect))
- g_warning ("gdk_window_get_geometry: GetClientRect failed");
+ if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
+ WIN32_API_FAILED ("GetClientRect");
if (x)
*x = rect.left;
if (height)
*height = rect.bottom - rect.top;
if (depth)
- *depth = gdk_window_get_visual (window)->depth;
+ *depth = gdk_drawable_get_visual (window)->depth;
}
}
-void
-gdk_window_get_position (GdkWindow *window,
- gint *x,
- gint *y)
-{
- GdkWindowPrivate *window_private;
-
- g_return_if_fail (window != NULL);
-
- window_private = (GdkWindowPrivate*) window;
-
- if (x)
- *x = window_private->x;
- if (y)
- *y = window_private->y;
-}
-
-void
-gdk_window_get_size (GdkWindow *window,
- gint *width,
- gint *height)
-{
- GdkWindowPrivate *window_private;
-
- g_return_if_fail (window != NULL);
-
- window_private = (GdkWindowPrivate*) window;
-
- if (width)
- *width = window_private->width;
- if (height)
- *height = window_private->height;
-}
-
-GdkVisual*
-gdk_window_get_visual (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, NULL);
-
- window_private = (GdkWindowPrivate*) window;
- /* Huh? ->parent is never set for a pixmap. We should just return
- * null immeditately. Well, do it then!
- */
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
- return NULL;
-
- if (!window_private->destroyed)
- {
- if (window_private->colormap == NULL)
- return gdk_visual_get_system (); /* XXX ??? */
- else
- return ((GdkColormapPrivate *)window_private->colormap)->visual;
- }
-
- return NULL;
-}
-
-GdkColormap*
-gdk_window_get_colormap (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate*) window;
-
- g_return_val_if_fail (window_private->window_type != GDK_WINDOW_PIXMAP, NULL);
- if (!window_private->destroyed)
- {
- if (window_private->colormap == NULL)
- return gdk_colormap_get_system (); /* XXX ??? */
- else
- return window_private->colormap;
- }
-
- return NULL;
-}
-
-GdkWindowType
-gdk_window_get_type (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, (GdkWindowType) -1);
-
- window_private = (GdkWindowPrivate*) window;
- return window_private->window_type;
-}
-
gint
gdk_window_get_origin (GdkWindow *window,
gint *x,
gint *y)
{
- GdkWindowPrivate *private;
gint return_val;
gint tx = 0;
gint ty = 0;
g_return_val_if_fail (window != NULL, 0);
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
POINT pt;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
tx = pt.x;
ty = pt.y;
return_val = 1;
*x = tx;
if (y)
*y = ty;
-
+
+ GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %#x: +%d+%d\n",
+ GDK_DRAWABLE_XID (window), tx, ty));
return return_val;
}
gint *x,
gint *y)
{
- GdkWindowPrivate *private;
+ GdkWindowPrivate *rover;
POINT pt;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
+ rover = (GdkWindowPrivate*) window;
if (x)
*x = 0;
if (y)
*y = 0;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
- private = (GdkWindowPrivate*) private->parent;
- if (private->destroyed)
+ while (rover->parent && ((GdkWindowPrivate*) rover->parent)->parent)
+ rover = (GdkWindowPrivate *) rover->parent;
+ if (rover->drawable.destroyed)
return;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (rover), &pt);
if (x)
*x = pt.x;
if (y)
*y = pt.y;
+
+ GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
+ GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (rover), pt.x, pt.y));
}
GdkWindow*
gint *y,
GdkModifierType *mask)
{
- GdkWindowPrivate *private;
GdkWindow *return_val;
POINT pointc, point;
HWND hwnd, hwndc;
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
+
if (!window)
- window = (GdkWindow*) &gdk_root_parent;
-
- private = (GdkWindowPrivate*) window;
+ window = gdk_parent_root;
return_val = NULL;
GetCursorPos (&pointc);
point = pointc;
- ScreenToClient (private->xwindow, &point);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &point);
if (x)
*x = point.x;
gdk_window_at_pointer (gint *win_x,
gint *win_y)
{
- GdkWindowPrivate *private;
GdkWindow *window;
POINT point, pointc;
HWND hwnd, hwndc;
RECT rect;
- private = &gdk_root_parent;
-
GetCursorPos (&pointc);
point = pointc;
hwnd = WindowFromPoint (point);
if (hwnd == NULL)
{
- window = (GdkWindow *) &gdk_root_parent;
+ window = gdk_parent_root;
if (win_x)
*win_x = pointc.x;
if (win_y)
return window;
}
-GdkWindow*
-gdk_window_get_parent (GdkWindow *window)
-{
- g_return_val_if_fail (window != NULL, NULL);
-
- return ((GdkWindowPrivate*) window)->parent;
-}
-
-GdkWindow*
-gdk_window_get_toplevel (GdkWindow *window)
-{
- GdkWindowPrivate *private;
-
- g_return_val_if_fail (window != NULL, NULL);
-
- private = (GdkWindowPrivate*) window;
-
- while (private->window_type == GDK_WINDOW_CHILD)
- {
- window = ((GdkWindowPrivate*) window)->parent;
- private = (GdkWindowPrivate*) window;
- }
-
- return window;
-}
-
GList*
gdk_window_get_children (GdkWindow *window)
{
GList *children;
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
/* XXX ??? */
- g_warning ("gdk_window_get_children ???");
+ g_warning ("gdk_window_get_children not implemented");
children = NULL;
return children;
GdkEventMask
gdk_window_get_events (GdkWindow *window)
{
- GdkWindowPrivate *private;
- GdkEventMask event_mask;
-
g_return_val_if_fail (window != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return 0;
- event_mask = 0;
-
- event_mask = private->event_mask;
-
- return event_mask;
+ return GDK_WINDOW_WIN32DATA (window)->event_mask;
}
void
gdk_window_set_events (GdkWindow *window,
GdkEventMask event_mask)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- private->event_mask = event_mask;
+ GDK_WINDOW_WIN32DATA (window)->event_mask = event_mask;
}
void
gdk_window_add_colormap_windows (GdkWindow *window)
{
- g_warning ("gdk_window_add_colormap_windows not implemented"); /* XXX */
+ g_warning ("gdk_window_add_colormap_windows not implemented");
}
-/*
- * This needs the X11 shape extension.
- * If not available, shaped windows will look
- * ugly, but programs still work. Stefan Wille
- */
void
gdk_window_shape_combine_mask (GdkWindow *window,
GdkBitmap *mask,
gint x, gint y)
{
- GdkWindowPrivate *window_private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
-
if (!mask)
{
GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x none\n",
- window_private->xwindow));
- SetWindowRgn (window_private->xwindow, NULL, TRUE);
+ GDK_DRAWABLE_XID (window)));
+ SetWindowRgn (GDK_DRAWABLE_XID (window), NULL, TRUE);
}
else
{
- GdkPixmapPrivate *pixmap_private;
HRGN hrgn;
DWORD dwStyle;
DWORD dwExStyle;
RECT rect;
/* Convert mask bitmap to region */
- pixmap_private = (GdkPixmapPrivate*) mask;
- hrgn = BitmapToRegion (pixmap_private->xwindow);
+ hrgn = BitmapToRegion (GDK_DRAWABLE_XID (mask));
GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
- window_private->xwindow,
- pixmap_private->xwindow));
+ GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (mask)));
/* SetWindowRgn wants window (not client) coordinates */
- dwStyle = GetWindowLong (window_private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
- GetClientRect (window_private->xwindow, &rect);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
OffsetRgn (hrgn, -rect.left, -rect.top);
OffsetRgn (hrgn, x, y);
/* If this is a top-level window, add the title bar to the region */
- if (window_private->window_type == GDK_WINDOW_TOPLEVEL)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
{
CombineRgn (hrgn, hrgn,
CreateRectRgn (0, 0, rect.right - rect.left, -rect.top),
RGN_OR);
}
- SetWindowRgn (window_private->xwindow, hrgn, TRUE);
- }
-}
-
-void
-gdk_window_add_filter (GdkWindow *window,
- GdkFilterFunc function,
- gpointer data)
-{
- GdkWindowPrivate *private;
- GList *tmp_list;
- GdkEventFilter *filter;
-
- private = (GdkWindowPrivate*) window;
- if (private && private->destroyed)
- return;
-
- if (private)
- tmp_list = private->filters;
- else
- tmp_list = gdk_default_filters;
-
- while (tmp_list)
- {
- filter = (GdkEventFilter *)tmp_list->data;
- if ((filter->function == function) && (filter->data == data))
- return;
- tmp_list = tmp_list->next;
- }
-
- filter = g_new (GdkEventFilter, 1);
- filter->function = function;
- filter->data = data;
-
- if (private)
- private->filters = g_list_append (private->filters, filter);
- else
- gdk_default_filters = g_list_append (gdk_default_filters, filter);
-}
-
-void
-gdk_window_remove_filter (GdkWindow *window,
- GdkFilterFunc function,
- gpointer data)
-{
- GdkWindowPrivate *private;
- GList *tmp_list, *node;
- GdkEventFilter *filter;
-
- private = (GdkWindowPrivate*) window;
-
- if(private)
- tmp_list = private->filters;
- else
- tmp_list = gdk_default_filters;
-
- while (tmp_list)
- {
- filter = (GdkEventFilter *)tmp_list->data;
- node = tmp_list;
- tmp_list = tmp_list->next;
-
- if ((filter->function == function) && (filter->data == data))
- {
- if(private)
- private->filters = g_list_remove_link (private->filters, node);
- else
- gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
- g_list_free_1 (node);
- g_free (filter);
-
- return;
- }
+ SetWindowRgn (GDK_DRAWABLE_XID (window), hrgn, TRUE);
}
}
gdk_window_set_override_redirect (GdkWindow *window,
gboolean override_redirect)
{
- g_warning ("gdk_window_set_override_redirect not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ g_warning ("gdk_window_set_override_redirect not implemented");
}
void
GdkPixmap *pixmap,
GdkBitmap *mask)
{
- g_warning ("gdk_window_set_icon not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
+
+ /* Nothing to do, really. As we share window classes between windows
+ * we can't have window-specific icons, sorry. Don't print any warning
+ * either.
+ */
}
-void
-gdk_window_set_icon_name (GdkWindow *window,
- gchar *name)
+void
+gdk_window_set_icon_name (GdkWindow *window,
+ const gchar *name)
{
- GdkWindowPrivate *window_private;
-
g_return_if_fail (window != NULL);
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
- return;
+ g_return_if_fail (GDK_IS_WINDOW (window));
- if (!SetWindowText (window_private->xwindow, name))
- g_warning ("gdk_window_set_icon_name: SetWindowText failed");
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
+
+ if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
+ WIN32_API_FAILED ("SetWindowText");
}
void
gdk_window_set_group (GdkWindow *window,
GdkWindow *leader)
{
- g_warning ("gdk_window_set_group not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (leader != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (leader));
+
+ if (GDK_DRAWABLE_DESTROYED (window) || GDK_DRAWABLE_DESTROYED (leader))
+ return;
+
+ g_warning ("gdk_window_set_group not implemented");
}
void
gdk_window_set_decorations (GdkWindow *window,
GdkWMDecoration decorations)
{
- GdkWindowPrivate *window_private = (GdkWindowPrivate *) window;
LONG style, exstyle;
- style = GetWindowLong (window_private->xwindow, GWL_STYLE);
- exstyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
if (decorations & GDK_DECOR_MAXIMIZE)
style |= (WS_MAXIMIZEBOX);
- SetWindowLong (window_private->xwindow, GWL_STYLE, style);
+ SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
}
void
gdk_window_set_functions (GdkWindow *window,
GdkWMFunction functions)
{
- GdkWindowPrivate *window_private = (GdkWindowPrivate *) window;
LONG style, exstyle;
- style = GetWindowLong (window_private->xwindow, GWL_STYLE);
- exstyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
if (functions & GDK_FUNC_MAXIMIZE)
style |= (WS_MAXIMIZEBOX);
- SetWindowLong (window_private->xwindow, GWL_STYLE, style);
-}
-
-GList *
-gdk_window_get_toplevels (void)
-{
- GList *new_list = NULL;
- GList *tmp_list;
-
- tmp_list = gdk_root_parent.children;
- while (tmp_list)
- {
- new_list = g_list_prepend (new_list, tmp_list->data);
- tmp_list = tmp_list->next;
- }
-
- return new_list;
+ SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
}
/*
WINDOWPLACEMENT placement;
placement.length = sizeof (WINDOWPLACEMENT);
- /* go through all child windows and create/insert spans */
+ /* go through all child windows and combine regions */
for (i = 0; i < num; i++)
{
GetWindowPlacement (list[i], &placement);
- if (placement.showCmd = SW_SHOWNORMAL)
+ if (placement.showCmd == SW_SHOWNORMAL)
{
childRegion = CreateRectRgnIndirect (&emptyRect);
GetWindowRgn (list[i], childRegion);
CombineRgn (region, region, childRegion, RGN_OR);
+ DeleteObject (childRegion);
}
}
SetWindowRgn (win, region, TRUE);
}
+ else
+ DeleteObject (region);
}
void
gdk_window_set_child_shapes (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- gdk_propagate_shapes ( private->xwindow, FALSE);
+ gdk_propagate_shapes (GDK_DRAWABLE_XID (window), FALSE);
}
void
gdk_window_merge_child_shapes (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- gdk_propagate_shapes (private->xwindow, TRUE);
-}
-
-/*************************************************************
- * gdk_window_is_visible:
- * Check if the given window is mapped.
- * arguments:
- * window:
- * results:
- * is the window mapped
- *************************************************************/
-
-gboolean
-gdk_window_is_visible (GdkWindow *window)
-{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
- g_return_val_if_fail (window != NULL, FALSE);
-
- return private->mapped;
+ gdk_propagate_shapes (GDK_DRAWABLE_XID (window), TRUE);
}
-/*************************************************************
- * gdk_window_is_viewable:
- * Check if the window and all ancestors of the window
- * are mapped. (This is not necessarily "viewable" in
- * the X sense, since we only check as far as we have
- * GDK window parents, not to the root window)
- * arguments:
- * window:
- * results:
- * is the window viewable
- *************************************************************/
-
-gboolean
-gdk_window_is_viewable (GdkWindow *window)
-{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
- g_return_val_if_fail (window != NULL, FALSE);
-
- while (private &&
- (private != &gdk_root_parent) &&
- (private->window_type != GDK_WINDOW_FOREIGN))
- {
- if (!private->mapped)
- return FALSE;
-
- private = (GdkWindowPrivate *)private->parent;
- }
-
- return TRUE;
-}
-
-void
-gdk_drawable_set_data (GdkDrawable *drawable,
- const gchar *key,
- gpointer data,
- GDestroyNotify destroy_func)
-{
- g_dataset_set_data_full (drawable, key, data, destroy_func);
-}
-
-
/* Support for windows that can be guffaw-scrolled
* (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
*/
{
enum { UNKNOWN, NO, YES };
static gint gravity_works = UNKNOWN;
-
+
if (gravity_works == UNKNOWN)
{
GdkWindowAttr attr;
attr.window_type = GDK_WINDOW_CHILD;
child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
-
+
gdk_window_set_static_win_gravity (child, TRUE);
gdk_window_resize (parent, 100, 110);
gdk_window_destroy (parent);
gdk_window_destroy (child);
-
+
gravity_works = ((y == -20) ? YES : NO);
}
-
+
return (gravity_works == YES);
}
static void
gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
g_return_if_fail (window != NULL);
- GDK_NOTE (MISC,
- g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
+ GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
}
static void
gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
g_return_if_fail (window != NULL);
GDK_NOTE (MISC,
{
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
GList *tmp_list;
-
- g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
+
if (!use_static == !private->guffaw_gravity)
return TRUE;
if (use_static && !gdk_window_gravity_works ())
return FALSE;
-
+
private->guffaw_gravity = use_static;
-
- gdk_window_set_static_bit_gravity (window, use_static);
-
- tmp_list = private->children;
- while (tmp_list)
+
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- gdk_window_set_static_win_gravity (window, use_static);
+ gdk_window_set_static_bit_gravity (window, use_static);
- tmp_list = tmp_list->next;
+ tmp_list = private->children;
+ while (tmp_list)
+ {
+ gdk_window_set_static_win_gravity (window, use_static);
+
+ tmp_list = tmp_list->next;
+ }
}
-
+
return TRUE;
}
projects / ~andy / gtk / blobdiff