#include "gdkevents.h"
#include "gdkpixmap.h"
#include "gdkwindow.h"
+#include "gdkinternals.h"
#include "gdkprivate.h"
+#include "gdkprivate-win32.h"
#include "gdkinputprivate.h"
-#include "gdkx.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.
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;
}
-/* 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");
+ }
- pt.x = x;
- pt.y = y;
- /* This is probably not correct, just a quick hack */
+ 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);
- if (!warned)
+ g_free (GDK_DRAWABLE_WIN32DATA (drawable));
+}
+
+static GdkWindow *
+gdk_win32_window_alloc (void)
+{
+ GdkWindow *window;
+ GdkWindowPrivate *private;
+
+ static gboolean initialized = FALSE;
+
+ 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;
- gdk_root_parent.drawable.xwindow = gdk_root_window;
- gdk_root_parent.drawable.window_type = GDK_WINDOW_ROOT;
- gdk_root_parent.drawable.drawable.user_data = NULL;
- gdk_root_parent.drawable.width = width;
- gdk_root_parent.drawable.height = height;
- gdk_root_parent.drawable.ref_count = 1;
- gdk_root_parent.drawable.colormap = NULL;
- gdk_root_parent.children = NULL;
+ SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
+ width = r.right - r.left;
+ height = r.bottom - r.top;
- gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
+ 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
* get its own class
*/
ATOM
-RegisterGdkClass(GdkWindowType wtype)
+RegisterGdkClass (GdkDrawableType wtype)
{
static ATOM klassTOPLEVEL = 0;
static ATOM klassDIALOG = 0;
break;
}
+ if (klass == 0)
+ {
+ WIN32_API_FAILED ("RegisterClassEx");
+ g_error ("That is a fatal error");
+ }
return klass;
-} /* RegisterGdkClass */
-
+}
GdkWindow*
gdk_window_new (GdkWindow *parent,
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 (GDK_DRAWABLE_DESTROYED (parent))
return NULL;
- xparent = parent_private->drawable.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->drawable.destroyed = FALSE;
- private->mapped = FALSE;
- private->guffaw_gravity = FALSE;
- private->resize_count = 0;
- private->drawable.ref_count = 1;
-
private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
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;
- private->extension_events = 0;
- private->extension_events_selected = FALSE;
-
- private->filters = NULL;
- private->children = NULL;
-
- window->user_data = NULL;
+ 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;
- private->xcursor = NULL;
+ GDK_WINDOW_WIN32DATA (window)->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
if (parent_private && parent_private->guffaw_gravity)
{
{
dwExStyle = WS_EX_TRANSPARENT;
private->drawable.colormap = NULL;
- private->bg_type = GDK_WIN32_BG_TRANSPARENT;
- private->bg_pixmap = NULL;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_TRANSPARENT;
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
}
if (attributes_mask & GDK_WA_X)
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:
}
klass = RegisterGdkClass (private->drawable.window_type);
- if (!klass)
- g_error ("RegisterClassEx failed");
if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
rect.right = rect.left + private->drawable.width;
rect.bottom = rect.top + private->drawable.height;
- if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
- g_warning ("gdk_window_new: AdjustWindowRectEx failed");
+ SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
if (x != CW_USEDEFAULT)
{
height = private->drawable.height;
}
- private->drawable.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,
MAKEINTRESOURCE(klass),
- title,
+ mbtitle,
dwStyle,
x, y,
width, height,
NULL,
gdk_ProgInstance,
NULL);
+
GDK_NOTE (MISC,
- g_print ("gdk_window_create: %s %s %#x %#x %dx%d@+%d+%d %#x = %#x\n",
+ 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,
- private->event_mask,
+ mbtitle,
width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
xparent,
- private->drawable.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->drawable.xwindow, window);
+ if (GDK_DRAWABLE_XID (window) == NULL)
+ {
+ WIN32_API_FAILED ("CreateWindowEx");
+ g_free (GDK_DRAWABLE_WIN32DATA (window));
+ g_free (private);
+ return NULL;
+ }
+
+ gdk_drawable_ref (window);
+ gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
if (private->drawable.colormap)
gdk_colormap_ref (private->drawable.colormap);
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->drawable.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->drawable.width = rect.right - rect.left;
private->drawable.height = rect.bottom - rect.top;
- private->resize_count = 0;
- private->drawable.ref_count = 1;
private->drawable.window_type = GDK_WINDOW_FOREIGN;
private->drawable.destroyed = FALSE;
- private->mapped = IsWindowVisible (private->drawable.xwindow);
- private->guffaw_gravity = FALSE;
- private->extension_events = 0;
- private->extension_events_selected = FALSE;
+ private->mapped = IsWindowVisible (GDK_DRAWABLE_XID (window));
private->drawable.colormap = NULL;
- private->filters = NULL;
- private->children = NULL;
-
- window->user_data = NULL;
-
- gdk_window_ref (window);
- gdk_xid_table_insert (&private->drawable.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->drawable.xwindow));
+ GDK_DRAWABLE_XID (window)));
- switch (private->drawable.window_type)
+ switch (GDK_DRAWABLE_TYPE (window))
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
* OTOH, I don't think foreign windows are much
* used, so the question is maybe academic.
*/
- PostMessage (private->drawable.xwindow, WM_QUIT, 0, 0);
+ PostMessage (GDK_DRAWABLE_XID (window), WM_QUIT, 0, 0);
}
}
else if (xdestroy)
- DestroyWindow (private->drawable.xwindow);
+ DestroyWindow (GDK_DRAWABLE_XID (window));
if (private->drawable.colormap)
gdk_colormap_unref (private->drawable.colormap);
break;
case GDK_DRAWABLE_PIXMAP:
- g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
+ 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)
{
g_return_if_fail (window != NULL);
- GDK_NOTE (EVENTS, g_print ("gdk_window_destroy_notify: %#x %d\n",
- GDK_DRAWABLE_XID (window), GDK_DRAWABLE_DESTROYED (window)));
+ GDK_NOTE (EVENTS,
+ g_print ("gdk_window_destroy_notify: %#x %s\n",
+ GDK_DRAWABLE_XID (window),
+ (GDK_DRAWABLE_DESTROYED (window) ? "yes" : "no")));
if (!GDK_DRAWABLE_DESTROYED (window))
{
if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
- g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_DRAWABLE_XID (window));
+ g_warning ("window %#x unexpectedly destroyed",
+ GDK_DRAWABLE_XID (window));
gdk_window_internal_destroy (window, FALSE, FALSE);
}
gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
- gdk_window_unref (window);
-}
-
-GdkWindow*
-gdk_window_ref (GdkWindow *window)
-{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- g_return_val_if_fail (window != NULL, NULL);
-
- private->drawable.ref_count += 1;
-
- GDK_NOTE (MISC, g_print ("gdk_window_ref %#x %d\n",
- GDK_DRAWABLE_XID (window),
- private->drawable.ref_count));
-
- return window;
-}
-
-void
-gdk_window_unref (GdkWindow *window)
-{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- g_return_if_fail (window != NULL);
-
- private->drawable.ref_count -= 1;
-
- GDK_NOTE (MISC, g_print ("gdk_window_unref %#x %d%s\n",
- private->drawable.xwindow,
- private->drawable.ref_count,
- (private->drawable.ref_count == 0 ? " freeing" : "")));
-
- if (private->drawable.ref_count == 0)
- {
- if (private->bg_type == GDK_WIN32_BG_PIXMAP
- && private->bg_pixmap != NULL)
- gdk_pixmap_unref (private->bg_pixmap);
-
- if (!private->drawable.destroyed)
- {
- if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
- gdk_xid_table_remove (private->drawable.xwindow);
- else
- g_warning ("losing last reference to undestroyed window");
- }
- g_dataset_destroy (window);
- g_free (window);
- }
+ gdk_drawable_unref (window);
}
void
gdk_window_show (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->drawable.destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
- private->drawable.xwindow));
+ GDK_DRAWABLE_XID (window)));
- private->mapped = TRUE;
- if (private->drawable.window_type == GDK_WINDOW_TEMP)
+ ((GdkWindowPrivate *) window)->mapped = TRUE;
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TEMP)
{
- ShowWindow (private->drawable.xwindow, SW_SHOWNOACTIVATE);
- SetWindowPos (private->drawable.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->drawable.xwindow, SW_HIDE); /* Don't put on toolbar */
+ /* Don't put on toolbar */
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
#endif
}
else
{
- ShowWindow (private->drawable.xwindow, SW_SHOWNORMAL);
- ShowWindow (private->drawable.xwindow, SW_RESTORE);
- SetForegroundWindow (private->drawable.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->drawable.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->drawable.destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
- private->drawable.xwindow));
+ GDK_DRAWABLE_XID (window)));
- private->mapped = FALSE;
- if (private->drawable.window_type == GDK_WINDOW_TOPLEVEL)
- ShowOwnedPopups (private->drawable.xwindow, FALSE);
+ ((GdkWindowPrivate *) window)->mapped = FALSE;
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
+ ShowOwnedPopups (GDK_DRAWABLE_XID (window), FALSE);
#if 1
- ShowWindow (private->drawable.xwindow, SW_HIDE);
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
#elif 0
- ShowWindow (private->drawable.xwindow, SW_MINIMIZE);
+ ShowWindow (GDK_DRAWABLE_XID (window), SW_MINIMIZE);
#else
- CloseWindow (private->drawable.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->drawable.destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
- private->drawable.xwindow));
+ GDK_DRAWABLE_XID (window)));
gdk_window_hide (window); /* XXX */
}
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->drawable.destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
- private->drawable.xwindow, x, y));
+ GDK_DRAWABLE_XID (window), x, y));
- GetClientRect (private->drawable.xwindow, &rect);
+ private = (GdkWindowPrivate *) window;
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
- if (private->drawable.window_type != GDK_WINDOW_CHILD)
+ if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
{
POINT ptTL, ptBR;
DWORD dwStyle;
ptTL.x = 0;
ptTL.y = 0;
- ClientToScreen (private->drawable.xwindow, &ptTL);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &ptTL);
rect.left = x;
rect.top = y;
ptBR.x = rect.right;
ptBR.y = rect.bottom;
- ClientToScreen (private->drawable.xwindow, &ptBR);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &ptBR);
rect.right = x + ptBR.x - ptTL.x;
rect.bottom = y + ptBR.y - ptTL.y;
- dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
- if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
- g_warning ("gdk_window_move: AdjustWindowRectEx failed");
+ 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;
private->y = y;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->drawable.xwindow,
+ GDK_DRAWABLE_XID (window),
rect.right - rect.left, rect.bottom - rect.top,
x, y));
- if (!MoveWindow (private->drawable.xwindow,
+ 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");
}
}
int x, y;
GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
- private->drawable.xwindow, width, height));
+ GDK_DRAWABLE_XID (window), width, height));
if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->drawable.xwindow, &pt);
+ 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 (private->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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_resize: AdjustWindowRectEx failed");
+ WIN32_API_FAILED ("AdjustWindowRectEx");
x = rect.left;
y = rect.top;
private->resize_count += 1;
- GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->drawable.xwindow, width, height, x, y));
- if (!MoveWindow (private->drawable.xwindow,
+ 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->drawable.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->drawable.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->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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->drawable.window_type == GDK_WINDOW_CHILD)
{
private->drawable.height = height;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->drawable.xwindow,
+ GDK_DRAWABLE_XID (window),
rect.right - rect.left, rect.bottom - rect.top,
rect.left, rect.top));
- if (!MoveWindow (private->drawable.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->drawable.destroyed && !parent_private->drawable.destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window)
+ && !GDK_DRAWABLE_DESTROYED (new_parent))
{
GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
- window_private->drawable.xwindow,
- parent_private->drawable.xwindow));
- if (!SetParent (window_private->drawable.xwindow, parent_private->drawable.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->drawable.xwindow,
+ if (!MoveWindow (GDK_DRAWABLE_XID (window),
x, y,
- window_private->drawable.width, window_private->drawable.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)) ||
g_return_if_fail (GDK_IS_WINDOW (window));
if (!GDK_DRAWABLE_DESTROYED (window))
- gdk_window_clear_area (window, 0, 0, -1, -1);
+ 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)
{
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (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",
+ 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, y + height);
+ 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)
{
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
{
RECT rect;
- GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
+ 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;
+ rect.bottom = y + height + 1;
if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
- g_warning ("gdk_window_clear_area_e: InvalidateRect failed");
+ WIN32_GDI_FAILED ("InvalidateRect");
UpdateWindow (GDK_DRAWABLE_XID (window));
}
}
GDK_DRAWABLE_XID (window)));
if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
- g_warning ("gdk_window_raise: BringWindowToTop failed");
+ WIN32_API_FAILED ("BringWindowToTop");
}
}
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;
if (GDK_DRAWABLE_DESTROYED (window))
return;
- private = (GdkWindowPrivate*) window;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
- private->drawable.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->drawable.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->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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->drawable.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->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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->drawable.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->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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->drawable.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;
if (GDK_DRAWABLE_DESTROYED (window))
return;
- private = (GdkWindowPrivate*) window;
-
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->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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->drawable.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->drawable.xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->drawable.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->drawable.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->drawable.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->drawable.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)
{
+ 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);
GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
GDK_DRAWABLE_XID (window), title));
if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (!SetWindowText (GDK_DRAWABLE_XID (window), 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_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 (!GDK_DRAWABLE_DESTROYED (window))
{
GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
- private->drawable.xwindow,
+ GDK_DRAWABLE_XID (window),
gdk_color_to_string (color)));
- if (private->bg_type == GDK_WIN32_BG_PIXMAP)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
{
- if (private->bg_pixmap != NULL)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
{
- gdk_pixmap_unref (private->bg_pixmap);
- private->bg_pixmap = NULL;
+ gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
}
- private->bg_type = GDK_WIN32_BG_NORMAL;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
}
- private->bg_type = GDK_WIN32_BG_PIXEL;
- private->bg_pixel = *color;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXEL;
+ GDK_WINDOW_WIN32DATA (window)->bg_pixel = color->pixel;
}
}
GdkPixmap *pixmap,
gint parent_relative)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (private->bg_type == GDK_WIN32_BG_PIXMAP)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
{
- if (private->bg_pixmap != NULL)
+ if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
{
- gdk_pixmap_unref (private->bg_pixmap);
- private->bg_pixmap = NULL;
+ gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
+ GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
}
- private->bg_type = GDK_WIN32_BG_NORMAL;
+ GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
}
if (parent_relative)
{
- private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
+ GDK_WINDOW_WIN32DATA (window)->bg_type =
+ GDK_WIN32_BG_PARENT_RELATIVE;
}
else if (!pixmap)
{
}
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
*/
- private->bg_type = GDK_WIN32_BG_PIXMAP;
- 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 (!GDK_DRAWABLE_DESTROYED (window))
xcursor = cursor_private->xcursor;
GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
- window_private->drawable.xwindow, xcursor));
- window_private->xcursor = xcursor;
- }
-}
+ GDK_DRAWABLE_XID (window), xcursor));
+ GDK_WINDOW_WIN32DATA (window)->xcursor = xcursor;
-void
-gdk_window_get_user_data (GdkWindow *window,
- gpointer *data)
-{
- g_return_if_fail (window != NULL);
-
- *data = window->user_data;
+ GetCursorPos (&pt);
+ if (ChildWindowFromPoint (GDK_DRAWABLE_XID (window), pt) == GDK_DRAWABLE_XID (window))
+ SetCursor (xcursor);
+ }
}
void
g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
if (!window)
- window = (GdkWindow*) &gdk_root_parent;
+ window = gdk_parent_root;
if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
- g_warning ("gdk_window_get_geometry: GetClientRect failed");
+ WIN32_API_FAILED ("GetClientRect");
if (x)
*x = rect.left;
}
}
-void
-gdk_window_get_position (GdkWindow *window,
- 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 (x)
- *x = window_private->x;
- if (y)
- *y = window_private->y;
-}
-
gint
gdk_window_get_origin (GdkWindow *window,
gint *x,
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)
if (GDK_DRAWABLE_DESTROYED (window))
return;
- while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
- private = (GdkWindowPrivate*) private->parent;
- if (private->drawable.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->drawable.xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (rover), &pt);
if (x)
*x = pt.x;
if (y)
GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
GDK_DRAWABLE_XID (window),
- private->drawable.xwindow, pt.x, pt.y));
+ GDK_DRAWABLE_XID (rover), pt.x, pt.y));
}
GdkWindow*
g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
if (!window)
- window = (GdkWindow*) &gdk_root_parent;
+ window = gdk_parent_root;
return_val = NULL;
GetCursorPos (&pointc);
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);
- g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
- return ((GdkWindowPrivate*) window)->parent;
-}
-
-GdkWindow*
-gdk_window_get_toplevel (GdkWindow *window)
-{
- g_return_val_if_fail (window != NULL, NULL);
- g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
- while (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_CHILD)
- window = ((GdkWindowPrivate*) window)->parent;
-
- return window;
-}
-
GList*
gdk_window_get_children (GdkWindow *window)
{
GdkEventMask
gdk_window_get_events (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_val_if_fail (window != NULL, 0);
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- private = (GdkWindowPrivate*) window;
if (GDK_DRAWABLE_DESTROYED (window))
return 0;
- return private->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 (GDK_DRAWABLE_DESTROYED (window))
return;
- private->event_mask = event_mask;
+ GDK_WINDOW_WIN32DATA (window)->event_mask = event_mask;
}
void
}
else
{
- GdkDrawablePrivate *pixmap_private;
HRGN hrgn;
DWORD dwStyle;
DWORD dwExStyle;
RECT rect;
/* Convert mask bitmap to region */
- pixmap_private = (GdkDrawablePrivate*) 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",
GDK_DRAWABLE_XID (window),
- pixmap_private->xwindow));
+ GDK_DRAWABLE_XID (mask)));
/* SetWindowRgn wants window (not client) coordinates */
dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
}
}
-void
-gdk_window_add_filter (GdkWindow *window,
- GdkFilterFunc function,
- gpointer data)
-{
- GdkWindowPrivate *private;
- GList *tmp_list;
- GdkEventFilter *filter;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (GDK_IS_WINDOW (window));
-
- private = (GdkWindowPrivate*) window;
- if (private && GDK_DRAWABLE_DESTROYED (window))
- 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;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (GDK_IS_WINDOW (window));
-
- 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, node);
- g_list_free_1 (node);
- g_free (filter);
-
- return;
- }
- }
-}
-
void
gdk_window_set_override_redirect (GdkWindow *window,
gboolean override_redirect)
if (GDK_DRAWABLE_DESTROYED (window))
return;
- g_warning ("gdk_window_set_icon not implemented");
+ /* 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)
+gdk_window_set_icon_name (GdkWindow *window,
+ const gchar *name)
{
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
return;
if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
- g_warning ("gdk_window_set_icon_name: SetWindowText failed");
+ WIN32_API_FAILED ("SetWindowText");
}
void
SetWindowLong (GDK_DRAWABLE_XID (window), 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;
-}
-
/*
* propagate the shapes from all child windows of a GDK window to the parent
* window. Shamelessly ripped from Enlightenment's code
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);
gdk_propagate_shapes (GDK_DRAWABLE_XID (window), 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);
- g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-
- return private->mapped;
-}
-
-/*************************************************************
- * 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);
- g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-
- while (private &&
- (private != &gdk_root_parent) &&
- (private->drawable.window_type != GDK_WINDOW_FOREIGN))
- {
- if (!private->mapped)
- return FALSE;
-
- private = (GdkWindowPrivate *)private->parent;
- }
-
- return TRUE;
-}
-
/* Support for windows that can be guffaw-scrolled
* (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
*/
projects / ~andy / gtk / blobdiff