AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

CSW Win32 work in progress - builds but does not work yet.

Browse Source
This commit is contained in:
Cody Russell 2009-02-14 13:23:54 -05:00 committed by Alexander Larsson
parent 97996ff00c
commit a93c6cd6e1
14 changed files with 633 additions and 1166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gdk/gdkwindow.c
View File

@ -37,8 +37,10 @@
#undef DEBUG_WINDOW_PRINTING
#ifdef GDK_WINDOWING_X11
#if defined(GDK_WINDOWING_X11)
#include "x11/gdkx.h" /* For workaround */
#elif defined(GDK_WINDOWING_WIN32)
#include "win32/gdkwin32.h"
#endif
#include "math.h"

8
gdk/win32/gdkdisplay-win32.c
View File

@ -36,6 +36,12 @@ _gdk_windowing_set_default_display (GdkDisplay *display)
g_assert (display == NULL || _gdk_display == display);
}
gulong
_gdk_windowing_window_get_next_serial (GdkDisplay *display)
{
return 0;
}
#ifdef HAVE_MONITOR_INFO
static BOOL CALLBACK
count_monitor (HMONITOR hmonitor,
@ -200,7 +206,7 @@ gdk_display_open (const gchar *display_name)
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_window_init (_gdk_screen);
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init (_gdk_display);

29
gdk/win32/gdkdrawable-win32.c
View File

@ -1844,6 +1844,20 @@ _gdk_win32_drawable_release_dc (GdkDrawable *drawable)
}
}
cairo_surface_t *
_gdk_windowing_create_cairo_surface (GdkDrawable *drawable,
gint width,
gint height)
{
GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
HDC hdc = _gdk_win32_drawable_acquire_dc (drawable);
if (!hdc)
return NULL;
return cairo_win32_surface_create (hdc);
}
static void
gdk_win32_cairo_surface_destroy (void *data)
{
@ -1864,11 +1878,8 @@ gdk_win32_ref_cairo_surface (GdkDrawable *drawable)
if (!impl->cairo_surface)
{
HDC hdc = _gdk_win32_drawable_acquire_dc (drawable);
if (!hdc)
return NULL;
impl->cairo_surface = cairo_win32_surface_create (hdc);
// On Win32 cairo surface, width and height are determined from the DC
impl->cairo_surface = _gdk_windowing_create_cairo_surface (drawable, 0, 0);
cairo_surface_set_user_data (impl->cairo_surface, &gdk_win32_cairo_key,
drawable, gdk_win32_cairo_surface_destroy);
@ -1879,6 +1890,14 @@ gdk_win32_ref_cairo_surface (GdkDrawable *drawable)
return impl->cairo_surface;
}
void
_gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
gint width,
gint height)
{
// Do nothing. The surface size is determined by the DC
}
static gint
gdk_win32_get_depth (GdkDrawable *drawable)
{

47
gdk/win32/gdkevents-win32.c
View File

@ -653,6 +653,7 @@ find_window_for_mouse_event (GdkWindow* reported_window,
return find_real_window_for_grabbed_mouse_event (reported_window, msg);
}
#if 0
gboolean
gdk_display_pointer_is_grabbed (GdkDisplay *display)
{
@ -661,7 +662,9 @@ gdk_display_pointer_is_grabbed (GdkDisplay *display)
p_grab_window != NULL ? "TRUE" : "FALSE"));
return p_grab_window != NULL;
}
#endif
#if 0
gboolean
gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,
GdkWindow **grab_window,
@ -681,6 +684,7 @@ gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,
else
return FALSE;
}
#endif
GdkGrabStatus
gdk_keyboard_grab (GdkWindow *window,
@ -778,26 +782,6 @@ gdk_display_keyboard_ungrab (GdkDisplay *display,
assign_object (&k_grab_window, NULL);
}
gboolean
gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display,
GdkWindow **grab_window,
gboolean *owner_events)
{
g_return_val_if_fail (display == _gdk_display, FALSE);
if (k_grab_window)
{
if (grab_window)
*grab_window = k_grab_window;
if (owner_events)
*owner_events = k_grab_owner_events;
return TRUE;
}
else
return FALSE;
}
void
gdk_display_add_client_message_filter (GdkDisplay *display,
GdkAtom message_type,
@ -1399,7 +1383,7 @@ synthesize_enter_or_leave_event (GdkWindow *window,
event->crossing.window = window;
event->crossing.subwindow = NULL;
event->crossing.time = _gdk_win32_get_next_tick (msg->time);
_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
//_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
event->crossing.x = x + xoffset;
event->crossing.y = y + yoffset;
event->crossing.x_root = msg->pt.x + _gdk_offset_x;
@ -1855,6 +1839,7 @@ handle_configure_event (MSG *msg,
{
RECT client_rect;
POINT point;
GdkWindowObject *window_object;
GetClientRect (msg->hwnd, &client_rect);
point.x = client_rect.left; /* always 0 */
@ -1867,13 +1852,15 @@ handle_configure_event (MSG *msg,
point.y += _gdk_offset_y;
}
GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->width = client_rect.right - client_rect.left;
GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->height = client_rect.bottom - client_rect.top;
window_object = GDK_WINDOW_OBJECT (window);
((GdkWindowObject *) window)->x = point.x;
((GdkWindowObject *) window)->y = point.y;
window_object->width = client_rect.right - client_rect.left;
window_object->height = client_rect.bottom - client_rect.top;
if (((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK)
window_object->x = point.x;
window_object->y = point.y;
if (window_object->event_mask & GDK_STRUCTURE_MASK)
{
GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
@ -2037,7 +2024,7 @@ handle_wm_paint (MSG *msg,
update_region = _gdk_win32_hrgn_to_region (hrgn);
_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
//_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
gdk_region_offset (update_region, xoffset, yoffset);
_gdk_window_process_expose (window, update_region);
@ -2105,7 +2092,7 @@ generate_button_event (GdkEventType type,
translate_mouse_coords (orig_window, window, msg);
event->button.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
event->button.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
//_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
event->button.x += xoffset;
event->button.y += yoffset;
event->button.x_root = msg->pt.x + _gdk_offset_x;
@ -2825,7 +2812,7 @@ gdk_event_translate (MSG *msg,
event->motion.time = _gdk_win32_get_next_tick (msg->time);
event->motion.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
event->motion.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
// gdk_window_get_offsets (window, &xoffset, &yoffset);
event->motion.x += xoffset;
event->motion.y += yoffset;
event->motion.x_root = current_root_x;
@ -2916,7 +2903,7 @@ gdk_event_translate (MSG *msg,
event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
GDK_SCROLL_UP : GDK_SCROLL_DOWN;
event->scroll.time = _gdk_win32_get_next_tick (msg->time);
_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
//_gdk_win32_windowing_window_get_offsets (window, &xoffset, &yoffset);
event->scroll.x = (gint16) point.x + xoffset;
event->scroll.y = (gint16) point.y + yoffset;
event->scroll.x_root = (gint16) GET_X_LPARAM (msg->lParam) + _gdk_offset_x;

6
gdk/win32/gdkgc-win32.c
View File

@ -572,7 +572,8 @@ gdk_win32_gc_set_dashes (GdkGC *gc,
void
_gdk_windowing_gc_set_clip_region (GdkGC *gc,
const GdkRegion *region)
const GdkRegion *region,
gboolean reset_origin)
{
GdkGCWin32 *win32_gc = GDK_GC_WIN32 (gc);
@ -596,8 +597,11 @@ _gdk_windowing_gc_set_clip_region (GdkGC *gc,
win32_gc->values_mask &= ~GDK_GC_CLIP_MASK;
}
if (reset_origin)
{
gc->clip_x_origin = 0;
gc->clip_y_origin = 0;
}
win32_gc->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
}

577
gdk/win32/gdkgeometry-win32.c
View File

@ -42,197 +42,13 @@
#include "gdk.h" /* For gdk_rectangle_intersect */
#include "gdkregion.h"
#include "gdkregion-generic.h"
#include "gdkinternals.h"
#include "gdkprivate-win32.h"
#define SIZE_LIMIT 32767
typedef struct _GdkWindowParentPos GdkWindowParentPos;
struct _GdkWindowParentPos
{
gint x;
gint y;
gint win32_x;
gint win32_y;
GdkRectangle clip_rect;
};
static void gdk_window_compute_position (GdkWindowImplWin32 *window,
GdkWindowParentPos *parent_pos,
GdkWin32PositionInfo *info);
static void gdk_window_compute_parent_pos (GdkWindowImplWin32 *window,
GdkWindowParentPos *parent_pos);
static void gdk_window_postmove (GdkWindow *window,
GdkWindowParentPos *parent_pos,
gboolean anti_scroll);
static void gdk_window_tmp_unset_bg (GdkWindow *window);
static void gdk_window_tmp_reset_bg (GdkWindow *window);
static GdkRegion *gdk_window_clip_changed (GdkWindow *window,
GdkRectangle *old_clip,
GdkRectangle *new_clip);
static void gdk_window_post_scroll (GdkWindow *window,
GdkRegion *new_clip_region);
void
_gdk_win32_windowing_window_get_offsets (GdkWindow *window,
gint *x_offset,
gint *y_offset)
{
GdkWindowImplWin32 *impl =
GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
*x_offset = impl->position_info.x_offset;
*y_offset = impl->position_info.y_offset;
}
void
_gdk_window_init_position (GdkWindow *window)
{
GdkWindowParentPos parent_pos;
GdkWindowImplWin32 *impl;
g_return_if_fail (GDK_IS_WINDOW (window));
impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
gdk_window_compute_parent_pos (impl, &parent_pos);
gdk_window_compute_position (impl, &parent_pos, &impl->position_info);
}
void
_gdk_win32_window_scroll (GdkWindow *window,
gint dx,
gint dy)
{
GdkRegion *invalidate_region;
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GList *tmp_list;
GdkWindowParentPos parent_pos;
HRGN native_invalidate_region;
GDK_NOTE (EVENTS, g_print ("gdk_window_scroll: %p %d,%d\n",
GDK_WINDOW_HWND (window), dx, dy));
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
/* Move the current invalid region */
if (obj->update_area)
gdk_region_offset (obj->update_area, dx, dy);
gdk_window_compute_parent_pos (impl, &parent_pos);
parent_pos.x += obj->x;
parent_pos.y += obj->y;
parent_pos.win32_x += impl->position_info.x;
parent_pos.win32_y += impl->position_info.y;
parent_pos.clip_rect = impl->position_info.clip_rect;
gdk_window_tmp_unset_bg (window);
native_invalidate_region = CreateRectRgn (0, 0, 0, 0);
if (native_invalidate_region == NULL)
WIN32_API_FAILED ("CreateRectRgn");
API_CALL (ScrollWindowEx, (GDK_WINDOW_HWND (window),
dx, dy, NULL, NULL,
native_invalidate_region, NULL, SW_SCROLLCHILDREN));
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
tmp_list = obj->children;
while (tmp_list)
{
GDK_WINDOW_OBJECT(tmp_list->data)->x += dx;
GDK_WINDOW_OBJECT(tmp_list->data)->y += dy;
gdk_window_postmove (tmp_list->data, &parent_pos, FALSE);
tmp_list = tmp_list->next;
}
if (native_invalidate_region != NULL)
{
invalidate_region = _gdk_win32_hrgn_to_region (native_invalidate_region);
gdk_region_offset (invalidate_region, impl->position_info.x_offset,
impl->position_info.y_offset);
gdk_window_invalidate_region (window, invalidate_region, TRUE);
gdk_region_destroy (invalidate_region);
GDI_CALL (DeleteObject, (native_invalidate_region));
}
}
void
_gdk_win32_window_move_region (GdkWindow *window,
const GdkRegion *region,
gint dx,
gint dy)
{
GdkRegion *invalidate_region;
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkRectangle src_rect, dest_rect;
HRGN hrgn;
RECT clipRect, destRect;
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
/* Move the current invalid region */
if (obj->update_area)
gdk_region_offset (obj->update_area, dx, dy);
/* impl->position_info.clip_rect isn't meaningful for toplevels */
if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
src_rect = impl->position_info.clip_rect;
else
{
src_rect.x = 0;
src_rect.y = 0;
src_rect.width = impl->width;
src_rect.height = impl->height;
}
invalidate_region = gdk_region_rectangle (&src_rect);
dest_rect = src_rect;
dest_rect.x += dx;
dest_rect.y += dy;
gdk_rectangle_intersect (&dest_rect, &src_rect, &dest_rect);
if (dest_rect.width > 0 && dest_rect.height > 0)
{
GdkRegion *tmp_region;
tmp_region = gdk_region_rectangle (&dest_rect);
gdk_region_subtract (invalidate_region, tmp_region);
gdk_region_destroy (tmp_region);
}
/* no guffaw scroll on win32 */
hrgn = _gdk_win32_gdkregion_to_hrgn(invalidate_region, 0, 0);
gdk_region_destroy (invalidate_region);
destRect.left = dest_rect.y;
destRect.top = dest_rect.x;
destRect.right = dest_rect.x + dest_rect.width;
destRect.bottom = dest_rect.y + dest_rect.height;
clipRect.left = src_rect.y;
clipRect.top = src_rect.x;
clipRect.right = src_rect.x + src_rect.width;
clipRect.bottom = src_rect.y + src_rect.height;
g_print ("ScrollWindowEx(%d, %d, ...) - if you see this work, remove trace;)\n", dx, dy);
API_CALL(ScrollWindowEx, (GDK_WINDOW_HWND (window),
dx, dy, /* in: scroll offsets */
NULL, /* in: scroll rect, NULL == entire client area */
&clipRect, /* in: restrict to */
hrgn, /* in: update region */
NULL, /* out: update rect */
SW_INVALIDATE));
API_CALL(DeleteObject, (hrgn));
}
void
_gdk_window_move_resize_child (GdkWindow *window,
gint x,
@ -242,14 +58,8 @@ _gdk_window_move_resize_child (GdkWindow *window,
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkWin32PositionInfo new_info;
GdkWindowParentPos parent_pos;
GList *tmp_list;
gint d_xoffset, d_yoffset;
gint dx, dy;
gboolean is_move;
gboolean is_resize;
GdkRegion *new_clip_region;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
@ -257,385 +67,42 @@ _gdk_window_move_resize_child (GdkWindow *window,
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
is_move = (x - obj->x != 0) && (y - obj->y != 0);
is_resize = obj->width != width && obj->height != height;
GDK_NOTE (MISC, g_print ("_gdk_window_move_resize_child: %s@%+d%+d %dx%d@%+d%+d\n",
_gdk_win32_drawable_description (window),
obj->x, obj->y,
width, height, x, y));
obj->x, obj->y, width, height, x, y));
dx = x - obj->x;
dy = y - obj->y;
is_move = dx != 0 || dy != 0;
is_resize = impl->width != width || impl->height != height;
if (!is_move && !is_resize)
if (width > 65535 || height > 65535)
{
GDK_NOTE (MISC, g_print ("... neither move or resize\n"));
return;
}
g_warning ("Native children wider or taller than 65535 pixels are not supported.");
GDK_NOTE (MISC, g_print ("... %s%s\n",
is_move ? "is_move " : "",
is_resize ? "is_resize" : ""));
if (width > 65535)
width = 65535;
if (height > 65535)
height = 65535;
}
obj->x = x;
obj->y = y;
impl->width = width;
impl->height = height;
gdk_window_compute_parent_pos (impl, &parent_pos);
gdk_window_compute_position (impl, &parent_pos, &new_info);
new_clip_region =
gdk_window_clip_changed (window, &impl->position_info.clip_rect, &new_info.clip_rect);
parent_pos.x += obj->x;
parent_pos.y += obj->y;
parent_pos.win32_x += new_info.x;
parent_pos.win32_y += new_info.y;
parent_pos.clip_rect = new_info.clip_rect;
d_xoffset = new_info.x_offset - impl->position_info.x_offset;
d_yoffset = new_info.y_offset - impl->position_info.y_offset;
if (d_xoffset != 0 || d_yoffset != 0)
{
GDK_NOTE (MISC, g_print ("... d_offset=%+d%+d\n", d_xoffset, d_yoffset));
if (!ScrollWindowEx (GDK_WINDOW_HWND (window),
-d_xoffset, -d_yoffset, /* in: scroll offsets */
NULL, /* in: scroll rect, NULL == entire client area */
NULL, /* in: restrict to */
NULL, /* in: update region */
NULL, /* out: update rect */
SW_SCROLLCHILDREN))
WIN32_API_FAILED ("ScrollWindowEx");
if (dx != d_xoffset || dy != d_yoffset || is_resize)
{
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
"NOACTIVATE|NOZORDER%s%s)\n",
GDK_WINDOW_HWND (window),
new_info.x, new_info.y,
new_info.width, new_info.height,
(is_move ? "" : "|NOMOVE"),
(is_resize ? "" : "|NOSIZE")));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
new_info.x, new_info.y,
new_info.width, new_info.height,
SWP_NOACTIVATE | SWP_NOZORDER |
(is_move ? 0 : SWP_NOMOVE) |
(is_resize ? 0 : SWP_NOSIZE)));
}
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
if (!impl->position_info.mapped && new_info.mapped && GDK_WINDOW_IS_MAPPED (obj))
{
GDK_NOTE (MISC, g_print ("... ShowWindow(%p, SW_SHOWNA)\n",
GDK_WINDOW_HWND (window)));
ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNA);
}
impl->position_info = new_info;
tmp_list = obj->children;
while (tmp_list)
{
gdk_window_postmove (tmp_list->data, &parent_pos, FALSE);
tmp_list = tmp_list->next;
}
}
else
{
if (impl->position_info.mapped && !new_info.mapped)
{
GDK_NOTE (MISC, g_print ("... ShowWindow(%p, SW_HIDE)\n",
GDK_WINDOW_HWND (window)));
ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
}
obj->width = width;
obj->height = height;
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
"NOACTIVATE|NOZORDER%s%s)\n",
GDK_WINDOW_HWND (window),
new_info.x, new_info.y,
new_info.width, new_info.height,
obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y,
width, height,
(is_move ? "" : "|NOMOVE"),
(is_resize ? "" : "|NOSIZE")));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
new_info.x, new_info.y,
new_info.width, new_info.height,
obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y,
width, height,
SWP_NOACTIVATE | SWP_NOZORDER |
(is_move ? 0 : SWP_NOMOVE) |
(is_resize ? 0 : SWP_NOSIZE)));
tmp_list = obj->children;
while (tmp_list)
{
gdk_window_postmove (tmp_list->data, &parent_pos, FALSE);
tmp_list = tmp_list->next;
}
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
if (!impl->position_info.mapped && new_info.mapped && GDK_WINDOW_IS_MAPPED (obj))
{
GDK_NOTE (MISC, g_print ("... ShowWindow(%p, SW_SHOWNA)\n",
GDK_WINDOW_HWND (window)));
ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNA);
}
impl->position_info = new_info;
}
if (new_clip_region)
gdk_window_post_scroll (window, new_clip_region);
}
static void
gdk_window_compute_position (GdkWindowImplWin32 *window,
GdkWindowParentPos *parent_pos,
GdkWin32PositionInfo *info)
{
GdkWindowObject *wrapper;
int parent_x_offset;
int parent_y_offset;
g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (window));
wrapper = GDK_WINDOW_OBJECT (GDK_DRAWABLE_IMPL_WIN32 (window)->wrapper);
info->big = FALSE;
if (window->width <= SIZE_LIMIT)
{
info->width = window->width;
info->x = parent_pos->x + wrapper->x - parent_pos->win32_x;
}
else
{
info->big = TRUE;
info->width = SIZE_LIMIT;
if (parent_pos->x + wrapper->x < -(SIZE_LIMIT/2))
{
if (parent_pos->x + wrapper->x + window->width < (SIZE_LIMIT/2))
info->x = parent_pos->x + wrapper->x + window->width - info->width - parent_pos->win32_x;
else
info->x = -(SIZE_LIMIT/2) - parent_pos->win32_x;
}
else
info->x = parent_pos->x + wrapper->x - parent_pos->win32_x;
}
if (window->height <= SIZE_LIMIT)
{
info->height = window->height;
info->y = parent_pos->y + wrapper->y - parent_pos->win32_y;
}
else
{
info->big = TRUE;
info->height = SIZE_LIMIT;
if (parent_pos->y + wrapper->y < -(SIZE_LIMIT/2))
{
if (parent_pos->y + wrapper->y + window->height < (SIZE_LIMIT/2))
info->y = parent_pos->y + wrapper->y + window->height - info->height - parent_pos->win32_y;
else
info->y = -(SIZE_LIMIT/2) - parent_pos->win32_y;
}
else
info->y = parent_pos->y + wrapper->y - parent_pos->win32_y;
}
parent_x_offset = parent_pos->win32_x - parent_pos->x;
parent_y_offset = parent_pos->win32_y - parent_pos->y;
info->x_offset = parent_x_offset + info->x - wrapper->x;
info->y_offset = parent_y_offset + info->y - wrapper->y;
/* We don't considering the clipping of toplevel windows and their immediate children
* by their parents, and simply always map those windows.
*/
if (parent_pos->clip_rect.width == G_MAXINT)
info->mapped = TRUE;
/* Check if the window would wrap around into the visible space in either direction */
else if (info->x + parent_x_offset < parent_pos->clip_rect.x + parent_pos->clip_rect.width - 65536 ||
info->x + info->width + parent_x_offset > parent_pos->clip_rect.x + 65536 ||
info->y + parent_y_offset < parent_pos->clip_rect.y + parent_pos->clip_rect.height - 65536 ||
info->y + info->height + parent_y_offset > parent_pos->clip_rect.y + 65536)
info->mapped = FALSE;
else
info->mapped = TRUE;
info->no_bg = FALSE;
if (GDK_WINDOW_TYPE (wrapper) == GDK_WINDOW_CHILD)
{
info->clip_rect.x = wrapper->x;
info->clip_rect.y = wrapper->y;
info->clip_rect.width = window->width;
info->clip_rect.height = window->height;
gdk_rectangle_intersect (&info->clip_rect, &parent_pos->clip_rect, &info->clip_rect);
info->clip_rect.x -= wrapper->x;
info->clip_rect.y -= wrapper->y;
}
else
{
info->clip_rect.x = 0;
info->clip_rect.y = 0;
info->clip_rect.width = G_MAXINT;
info->clip_rect.height = G_MAXINT;
}
}
static void
gdk_window_compute_parent_pos (GdkWindowImplWin32 *window,
GdkWindowParentPos *parent_pos)
{
GdkWindowObject *wrapper;
GdkWindowObject *parent;
GdkRectangle tmp_clip;
int clip_xoffset = 0;
int clip_yoffset = 0;
g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (window));
wrapper = GDK_WINDOW_OBJECT (GDK_DRAWABLE_IMPL_WIN32 (window)->wrapper);
parent_pos->x = 0;
parent_pos->y = 0;
parent_pos->win32_x = 0;
parent_pos->win32_y = 0;
/* We take a simple approach here and simply consider toplevel
* windows not to clip their children on the right/bottom, since the
* size of toplevel windows is not directly under our
* control. Clipping only really matters when scrolling and
* generally we aren't going to be moving the immediate child of a
* toplevel beyond the bounds of that toplevel.
*
* We could go ahead and recompute the clips of toplevel windows and
* their descendents when we receive size notification, but it would
* probably not be an improvement in most cases.
*/
parent_pos->clip_rect.x = 0;
parent_pos->clip_rect.y = 0;
parent_pos->clip_rect.width = G_MAXINT;
parent_pos->clip_rect.height = G_MAXINT;
parent = (GdkWindowObject *)wrapper->parent;
while (parent && parent->window_type == GDK_WINDOW_CHILD)
{
GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (parent->impl);
tmp_clip.x = - clip_xoffset;
tmp_clip.y = - clip_yoffset;
tmp_clip.width = impl->width;
tmp_clip.height = impl->height;
gdk_rectangle_intersect (&parent_pos->clip_rect, &tmp_clip, &parent_pos->clip_rect);
parent_pos->x += parent->x;
parent_pos->y += parent->y;
parent_pos->win32_x += impl->position_info.x;
parent_pos->win32_y += impl->position_info.y;
clip_xoffset += parent->x;
clip_yoffset += parent->y;
parent = (GdkWindowObject *)parent->parent;
}
}
static void
gdk_window_postmove (GdkWindow *window,
GdkWindowParentPos *parent_pos,
gboolean anti_scroll)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkWin32PositionInfo new_info;
GList *tmp_list;
gint d_xoffset, d_yoffset;
GdkWindowParentPos this_pos;
GdkRegion *new_clip_region;
obj = (GdkWindowObject *) window;
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
gdk_window_compute_position (impl, parent_pos, &new_info);
new_clip_region =
gdk_window_clip_changed (window, &impl->position_info.clip_rect, &new_info.clip_rect);
this_pos.x = parent_pos->x + obj->x;
this_pos.y = parent_pos->y + obj->y;
this_pos.win32_x = parent_pos->win32_x + new_info.x;
this_pos.win32_y = parent_pos->win32_y + new_info.y;
this_pos.clip_rect = new_info.clip_rect;
if (impl->position_info.mapped && !new_info.mapped)
ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
d_xoffset = new_info.x_offset - impl->position_info.x_offset;
d_yoffset = new_info.y_offset - impl->position_info.y_offset;
if (anti_scroll || (anti_scroll = d_xoffset != 0 || d_yoffset != 0))
{
GDK_NOTE (MISC, g_print ("gdk_window_postmove: %s@%+d%+d\n"
"... SetWindowPos(%p,NULL,%d,%d,0,0,"
"NOREDRAW|NOZORDER|NOACTIVATE|NOSIZE)\n",
_gdk_win32_drawable_description (window),
obj->x, obj->y,
GDK_WINDOW_HWND (window),
new_info.x, new_info.y));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
new_info.x, new_info.y,
0, 0,
SWP_NOREDRAW | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE));
}
if (!impl->position_info.mapped && new_info.mapped && GDK_WINDOW_IS_MAPPED (obj))
ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNA);
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
impl->position_info = new_info;
if (new_clip_region)
gdk_window_post_scroll (window, new_clip_region);
tmp_list = obj->children;
while (tmp_list)
{
gdk_window_postmove (tmp_list->data, &this_pos, anti_scroll);
tmp_list = tmp_list->next;
}
}
gboolean
_gdk_windowing_window_queue_antiexpose (GdkWindow *window,
GdkRegion *area)
{
HRGN hrgn = _gdk_win32_gdkregion_to_hrgn (area, 0, 0);
GDK_NOTE (EVENTS, g_print ("_gdk_windowing_window_queue_antiexpose: ValidateRgn %p %s\n",
GDK_WINDOW_HWND (window),
_gdk_win32_gdkregion_to_string (area)));
ValidateRgn (GDK_WINDOW_HWND (window), hrgn);
DeleteObject (hrgn);
return FALSE;
}
void
@ -649,11 +116,9 @@ _gdk_window_process_expose (GdkWindow *window,
GDK_NOTE (EVENTS, g_print ("_gdk_window_process_expose: %p %s\n",
GDK_WINDOW_HWND (window),
_gdk_win32_gdkregion_to_string (invalidate_region)));
clip_region = gdk_region_rectangle (&impl->position_info.clip_rect);
gdk_region_intersect (invalidate_region, clip_region);
if (!gdk_region_empty (invalidate_region))
gdk_window_invalidate_region (window, invalidate_region, FALSE);
_gdk_window_invalidate_for_expose (window, invalidate_region);
gdk_region_destroy (clip_region);
}
@ -667,7 +132,7 @@ gdk_window_tmp_unset_bg (GdkWindow *window)
obj = (GdkWindowObject *) window;
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
impl->position_info.no_bg = TRUE;
impl->no_bg = TRUE;
/*
* The X version sets background = None to avoid updateing for a moment.
@ -686,7 +151,7 @@ gdk_window_tmp_reset_bg (GdkWindow *window)
obj = (GdkWindowObject *) window;
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
impl->position_info.no_bg = FALSE;
impl->no_bg = FALSE;
}
static GdkRegion *

26
gdk/win32/gdkinput-win32.c
View File

@ -648,6 +648,7 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
gdouble *y_out)
{
GdkWindowImplWin32 *impl, *root_impl;
GdkWindowObject *window_object;
int i;
int x_axis = 0;
@ -656,6 +657,7 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
double device_width, device_height;
double x_offset, y_offset, x_scale, y_scale;
window_object = GDK_WINDOW_OBJECT (input_window);
impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (input_window->window)->impl);
for (i=0; i<gdkdev->info.num_axes; i++)
@ -673,16 +675,14 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
}
}
device_width = gdkdev->axes[x_axis].max_value -
gdkdev->axes[x_axis].min_value;
device_height = gdkdev->axes[y_axis].max_value -
gdkdev->axes[y_axis].min_value;
device_width = gdkdev->axes[x_axis].max_value - gdkdev->axes[x_axis].min_value;
device_height = gdkdev->axes[y_axis].max_value - gdkdev->axes[y_axis].min_value;
if (gdkdev->info.mode == GDK_MODE_SCREEN)
{
root_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl);
x_scale = root_impl->width / device_width;
y_scale = root_impl->height / device_height;
x_scale = GDK_WINDOW_OBJECT (_gdk_root)->width / device_width;
y_scale = GDK_WINDOW_OBJECT (_gdk_root)->height / device_height;
x_offset = - input_window->root_x;
y_offset = - input_window->root_y;
@ -692,26 +692,24 @@ gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev,
double device_aspect = (device_height*gdkdev->axes[y_axis].resolution) /
(device_width*gdkdev->axes[x_axis].resolution);
if (device_aspect * impl->width >= impl->height)
if (device_aspect * window_object->width >= window_object->height)
{
/* device taller than window */
x_scale = impl->width / device_width;
y_scale = (x_scale * gdkdev->axes[x_axis].resolution)
/ gdkdev->axes[y_axis].resolution;
x_scale = window_object->width / device_width;
y_scale = (x_scale * gdkdev->axes[x_axis].resolution) / gdkdev->axes[y_axis].resolution;
x_offset = 0;
y_offset = -(device_height * y_scale -
impl->height)/2;
y_offset = -(device_height * y_scale - window_object->height) / 2;
}
else
{
/* window taller than device */
y_scale = impl->height / device_height;
y_scale = window_object->height / device_height;
x_scale = (y_scale * gdkdev->axes[y_axis].resolution)
/ gdkdev->axes[x_axis].resolution;
y_offset = 0;
x_offset = - (device_width * x_scale - impl->width)/2;
x_offset = - (device_width * x_scale - window_object->width) / 2;
}
}

6
gdk/win32/gdkmain-win32.c
View File

@ -149,13 +149,15 @@ gdk_get_use_xshm (void)
gint
gdk_screen_get_width (GdkScreen *screen)
{
return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl)->width;
//return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl)->width;
return GDK_WINDOW_OBJECT (_gdk_root)->width;
}
gint
gdk_screen_get_height (GdkScreen *screen)
{
return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl)->height;
//return GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (_gdk_root)->impl)->height;
return GDK_WINDOW_OBJECT (_gdk_root)->height;
}
gint
gdk_screen_get_width_mm (GdkScreen *screen)

6
gdk/win32/gdkpixmap-win32.c
View File

@ -130,7 +130,7 @@ gdk_pixmap_impl_win32_get_size (GdkDrawable *drawable,
}
GdkPixmap*
gdk_pixmap_new (GdkDrawable *drawable,
_gdk_pixmap_new (GdkDrawable *drawable,
gint width,
gint height,
gint depth)
@ -348,7 +348,7 @@ static const unsigned char mirror[256] = {
};
GdkPixmap *
gdk_bitmap_create_from_data (GdkDrawable *drawable,
_gdk_bitmap_create_from_data (GdkDrawable *drawable,
const gchar *data,
gint width,
gint height)
@ -388,7 +388,7 @@ gdk_bitmap_create_from_data (GdkDrawable *drawable,
}
GdkPixmap*
gdk_pixmap_create_from_data (GdkDrawable *drawable,
_gdk_pixmap_create_from_data (GdkDrawable *drawable,
const gchar *data,
gint width,
gint height,

5
gdk/win32/gdkprivate-win32.h
View File

@ -112,6 +112,9 @@
#define GDK_IS_GC_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GC_WIN32))
#define GDK_GC_WIN32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GC_WIN32, GdkGCWin32Class))
//#define GDK_WINDOW_SCREEN(win) (_gdk_screen)
GdkScreen *GDK_WINDOW_SCREEN(GObject *win);
typedef struct _GdkColormapPrivateWin32 GdkColormapPrivateWin32;
typedef struct _GdkCursorPrivate GdkCursorPrivate;
typedef struct _GdkWin32SingleFont GdkWin32SingleFont;
@ -455,7 +458,7 @@ HICON _gdk_win32_pixbuf_to_hcursor (GdkPixbuf *pixbuf,
gboolean _gdk_win32_pixbuf_to_hicon_supports_alpha (void);
/* Initialization */
void _gdk_windowing_window_init (void);
void _gdk_windowing_window_init (GdkScreen *screen);
void _gdk_root_window_size_init (void);
void _gdk_monitor_init(void);
void _gdk_visual_init (void);

378
gdk/win32/gdkwindow-win32.c
View File

@ -39,10 +39,6 @@
static GdkColormap* gdk_window_impl_win32_get_colormap (GdkDrawable *drawable);
static void gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
GdkColormap *cmap);
static void gdk_window_impl_win32_get_size (GdkDrawable *drawable,
gint *width,
gint *height);
static GdkRegion* gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable);
static void gdk_window_impl_win32_init (GdkWindowImplWin32 *window);
static void gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass);
static void gdk_window_impl_win32_finalize (GObject *object);
@ -56,10 +52,17 @@ static gboolean _gdk_window_get_functions (GdkWindow *window,
#define WINDOW_IS_TOPLEVEL(window) \
(GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
static void gdk_window_impl_iface_init (GdkWindowImplIface *iface);
GdkScreen *
GDK_WINDOW_SCREEN (GObject *win)
{
return _gdk_screen;
}
GType
_gdk_window_impl_win32_get_type (void)
{
@ -107,8 +110,6 @@ _gdk_window_impl_get_type (void)
static void
gdk_window_impl_win32_init (GdkWindowImplWin32 *impl)
{
impl->width = 1;
impl->height = 1;
impl->toplevel_window_type = -1;
impl->hcursor = NULL;
impl->hicon_big = NULL;
@ -134,11 +135,6 @@ gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass)
drawable_class->set_colormap = gdk_window_impl_win32_set_colormap;
drawable_class->get_colormap = gdk_window_impl_win32_get_colormap;
drawable_class->get_size = gdk_window_impl_win32_get_size;
/* Visible and clip regions are the same */
drawable_class->get_clip_region = gdk_window_impl_win32_get_visible_region;
drawable_class->get_visible_region = gdk_window_impl_win32_get_visible_region;
}
static void
@ -236,6 +232,7 @@ gdk_window_impl_win32_set_colormap (GdkDrawable *drawable,
}
}
/*
static void
gdk_window_impl_win32_get_size (GdkDrawable *drawable,
gint *width,
@ -264,6 +261,7 @@ gdk_window_impl_win32_get_visible_region (GdkDrawable *drawable)
return gdk_region_rectangle (&result_rect);
}
*/
void
_gdk_root_window_size_init (void)
@ -277,12 +275,12 @@ _gdk_root_window_size_init (void)
for (i = 1; i < _gdk_num_monitors; i++)
gdk_rectangle_union (&rect, &_gdk_monitors[i].rect, &rect);
impl->width = rect.width;
impl->height = rect.height;
//impl->width = rect.width;
//impl->height = rect.height;
}
void
_gdk_windowing_window_init (void)
_gdk_windowing_window_init (GdkScreen *screen)
{
GdkWindowObject *private;
GdkDrawableImplWin32 *draw_impl;
@ -292,6 +290,7 @@ _gdk_windowing_window_init (void)
_gdk_root = g_object_new (GDK_TYPE_WINDOW, NULL);
private = (GdkWindowObject *)_gdk_root;
private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
private->impl_window = private;
draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
draw_impl->handle = GetDesktopWindow ();
@ -304,7 +303,12 @@ _gdk_windowing_window_init (void)
_gdk_root_window_size_init ();
_gdk_window_init_position (GDK_WINDOW (private));
private->x = 0;
private->y = 0;
private->abs_x = 0;
private->abs_y = 0;
// ### TODO: private->width = WidthOfScreen (screen-xscreen)
// private->height = HeightOfScreen (screen->xscreen) ????
gdk_win32_handle_table_insert ((HANDLE *) &draw_impl->handle, _gdk_root);
@ -486,36 +490,32 @@ RegisterGdkClass (GdkWindowType wtype, GdkWindowTypeHint wtype_hint)
return klass;
}
static GdkWindow*
gdk_window_new_internal (GdkWindow *parent,
void
_gdk_window_impl_new (GdkWindow *window,
GdkWindow *real_parent,
GdkScreen *screen,
GdkVisual *visual,
GdkEventMask event_mask,
GdkWindowAttr *attributes,
gint attributes_mask,
gboolean from_set_skip_taskbar_hint)
gint attributes_mask)
{
HWND hwndNew;
HANDLE hparent;
ATOM klass = 0;
DWORD dwStyle = 0, dwExStyle;
RECT rect;
GdkWindow *window;
GdkWindow *orig_parent;
GdkWindowObject *private;
GdkWindowImplWin32 *impl;
GdkDrawableImplWin32 *draw_impl;
GdkVisual *visual;
const gchar *title;
wchar_t *wtitle;
gint window_width, window_height;
gint offset_x = 0, offset_y = 0;
g_return_val_if_fail (attributes != NULL, NULL);
private = (GdkWindowObject *)window;
if (!parent)
parent = _gdk_root;
g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
orig_parent = parent;
orig_parent = real_parent;
GDK_NOTE (MISC,
g_print ("gdk_window_new_internal: %s\n",
@ -525,63 +525,28 @@ gdk_window_new_internal (GdkWindow *parent,
(attributes->window_type == GDK_WINDOW_TEMP ? "TEMP" :
"???"))))));
if (GDK_WINDOW_DESTROYED (parent))
return NULL;
hparent = GDK_WINDOW_HWND (real_parent);
hparent = GDK_WINDOW_HWND (parent);
window = g_object_new (GDK_TYPE_WINDOW, NULL);
private = (GdkWindowObject *)window;
private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
impl = g_object_new (_gdk_window_impl_get_type (), NULL);
private->impl = (GdkDrawable *)impl;
draw_impl->wrapper = GDK_DRAWABLE (window);
/* Windows with a foreign parent are treated as if they are children
* of the root window, except for actual creation.
*/
if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
parent = _gdk_root;
private->parent = (GdkWindowObject *)parent;
private->accept_focus = TRUE;
private->focus_on_map = TRUE;
if (attributes_mask & GDK_WA_X)
private->x = attributes->x;
else
private->x = 0;
if (attributes_mask & GDK_WA_Y)
private->y = attributes->y;
else if (attributes_mask & GDK_WA_X)
private->y = 100; /* ??? We must put it somewhere... */
else
private->y = 0;
// XXX: xattributes_mask = 0
#if 0
if (attributes_mask & GDK_WA_VISUAL)
visual = attributes->visual;
else
visual = gdk_visual_get_system ();
#endif
#if 0
impl->width = (attributes->width > 1) ? (attributes->width) : (1);
impl->height = (attributes->height > 1) ? (attributes->height) : (1);
#endif
impl->extension_events_selected = FALSE;
if (attributes->wclass == GDK_INPUT_ONLY)
{
/* Backwards compatiblity - we've always ignored
* attributes->window_type for input-only windows
* before
*/
if (parent == _gdk_root)
private->window_type = GDK_WINDOW_TEMP;
else
private->window_type = GDK_WINDOW_CHILD;
}
else
private->window_type = attributes->window_type;
// XXX ?
if (attributes->wclass == GDK_INPUT_OUTPUT)
{
dwExStyle = 0;
@ -618,10 +583,9 @@ gdk_window_new_internal (GdkWindow *parent,
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_DIALOG:
if (parent != _gdk_root)
if (GDK_WINDOW_TYPE (private->parent) != GDK_WINDOW_ROOT)
{
g_warning (G_STRLOC ": Toplevel windows must be created as children\n"
"of a window of type GDK_WINDOW_ROOT or GDK_WINDOW_FOREIGN");
/* The common code warns for this case. */
hparent = GetDesktopWindow ();
}
/* Children of foreign windows aren't toplevel windows */
@ -641,34 +605,32 @@ gdk_window_new_internal (GdkWindow *parent,
}
break;
/*
case GDK_WINDOW_CHILD:
dwStyle = WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
break;
*/
case GDK_WINDOW_TEMP:
/* A temp window is not necessarily a top level window */
dwStyle = (_gdk_root == parent ? WS_POPUP : WS_CHILDWINDOW);
dwStyle = (_gdk_root == real_parent ? WS_POPUP : WS_CHILDWINDOW);
dwStyle |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
dwExStyle |= WS_EX_TOOLWINDOW;
offset_x = _gdk_offset_x;
offset_y = _gdk_offset_y;
break;
case GDK_WINDOW_ROOT:
g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
default:
g_assert_not_reached ();
}
_gdk_window_init_position (GDK_WINDOW (private));
//_gdk_window_init_position (GDK_WINDOW (private));
if (private->window_type != GDK_WINDOW_CHILD)
{
rect.left = rect.top = 0;
rect.right = impl->position_info.width;
rect.bottom = impl->position_info.height;
rect.right = private->width;
rect.bottom = private->height;
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
@ -677,8 +639,8 @@ gdk_window_new_internal (GdkWindow *parent,
}
else
{
window_width = impl->position_info.width;
window_height = impl->position_info.height;
window_width = private->width;
window_height = private->height;
}
if (attributes_mask & GDK_WA_TITLE)
@ -710,8 +672,8 @@ gdk_window_new_internal (GdkWindow *parent,
wtitle,
dwStyle,
((attributes_mask & GDK_WA_X) ?
impl->position_info.x - offset_x : CW_USEDEFAULT),
impl->position_info.y - offset_y,
private->x - offset_x : CW_USEDEFAULT),
private->y - offset_y,
window_width, window_height,
hparent,
NULL,
@ -746,8 +708,8 @@ gdk_window_new_internal (GdkWindow *parent,
title,
window_width, window_height,
((attributes_mask & GDK_WA_X) ?
impl->position_info.x - offset_x: CW_USEDEFAULT),
impl->position_info.y - offset_y,
private->x - offset_x: CW_USEDEFAULT),
private->y - offset_y,
hparent,
GDK_WINDOW_HWND (window)));
@ -760,25 +722,15 @@ gdk_window_new_internal (GdkWindow *parent,
{
WIN32_API_FAILED ("CreateWindowExW");
g_object_unref (window);
return NULL;
return;
}
if (!from_set_skip_taskbar_hint && private->window_type == GDK_WINDOW_TEMP)
gdk_window_set_skip_taskbar_hint (window, TRUE);
// if (!from_set_skip_taskbar_hint && private->window_type == GDK_WINDOW_TEMP)
// gdk_window_set_skip_taskbar_hint (window, TRUE);
gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
(attributes->cursor) :
NULL));
return window;
}
GdkWindow*
_gdk_window_new (GdkWindow *parent,
GdkWindowAttr *attributes,
gint attributes_mask)
{
return gdk_window_new_internal (parent, attributes, attributes_mask, FALSE);
}
GdkWindow *
@ -819,8 +771,8 @@ gdk_window_foreign_new_for_display (GdkDisplay *display,
ScreenToClient (parent, &point);
private->x = point.x;
private->y = point.y;
impl->width = rect.right - rect.left;
impl->height = rect.bottom - rect.top;
private->width = rect.right - rect.left;
private->height = rect.bottom - rect.top;
private->window_type = GDK_WINDOW_FOREIGN;
private->destroyed = FALSE;
private->event_mask = GDK_ALL_EVENTS_MASK; /* XXX */
@ -836,7 +788,7 @@ gdk_window_foreign_new_for_display (GdkDisplay *display,
private->depth = gdk_visual_get_system ()->depth;
_gdk_window_init_position (GDK_WINDOW (private));
//_gdk_window_init_position (GDK_WINDOW (private));
g_object_ref (window);
gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window);
@ -956,11 +908,17 @@ get_outer_rect (GdkWindow *window,
}
static void
adjust_for_gravity_hints (GdkWindowImplWin32 *impl,
adjust_for_gravity_hints (GdkWindow *window,
RECT *outer_rect,
gint *x,
gint *y)
{
GdkWindowObject *obj;
GdkWindowImplWin32 *impl;
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
if (impl->hint_flags & GDK_HINT_WIN_GRAVITY)
{
gint orig_x = *x, orig_y = *y;
@ -971,14 +929,14 @@ adjust_for_gravity_hints (GdkWindowImplWin32 *impl,
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_SOUTH:
*x -= (outer_rect->right - outer_rect->left) / 2;
*x += impl->width / 2;
*x += obj->width / 2;
break;
case GDK_GRAVITY_SOUTH_EAST:
case GDK_GRAVITY_EAST:
case GDK_GRAVITY_NORTH_EAST:
*x -= outer_rect->right - outer_rect->left;
*x += impl->width;
*x += obj->width;
break;
case GDK_GRAVITY_STATIC:
@ -995,14 +953,14 @@ adjust_for_gravity_hints (GdkWindowImplWin32 *impl,
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_EAST:
*y -= (outer_rect->bottom - outer_rect->top) / 2;
*y += impl->height / 2;
*y += obj->height / 2;
break;
case GDK_GRAVITY_SOUTH_WEST:
case GDK_GRAVITY_SOUTH:
case GDK_GRAVITY_SOUTH_EAST:
*y -= outer_rect->bottom - outer_rect->top;
*y += impl->height;
*y += obj->height;
break;
case GDK_GRAVITY_STATIC:
@ -1039,7 +997,7 @@ show_window_internal (GdkWindow *window,
GDK_NOTE (MISC, g_print ("show_window_internal: %p: %s%s%s\n",
GDK_WINDOW_HWND (window),
_gdk_win32_window_state_to_string (private->state),
(raise ? " raise" : ""),
//(raise ? " raise" : ""),
(deiconify ? " deiconify" : "")));
/* If asked to show (not deiconify) an withdrawn and iconified
@ -1169,9 +1127,9 @@ show_window_internal (GdkWindow *window,
}
static void
gdk_win32_window_show (GdkWindow *window, gboolean raise)
gdk_win32_window_show (GdkWindow *window)
{
show_window_internal (window, raise, FALSE);
show_window_internal (window, FALSE, FALSE);
}
static void
@ -1251,15 +1209,15 @@ gdk_win32_window_move (GdkWindow *window,
*/
if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != GetDesktopWindow ())
{
_gdk_window_move_resize_child (window, x, y, impl->width, impl->height);
_gdk_window_move_resize_child (window, x, y, private->width, private->height);
}
else
{
RECT outer_rect;
get_outer_rect (window, impl->width, impl->height, &outer_rect);
get_outer_rect (window, private->width, private->height, &outer_rect);
adjust_for_gravity_hints (impl, &outer_rect, &x, &y);
adjust_for_gravity_hints (window, &outer_rect, &x, &y);
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,0,0,"
"NOACTIVATE|NOSIZE|NOZORDER)\n",
@ -1329,7 +1287,7 @@ gdk_win32_window_move_resize_internal (GdkWindow *window,
gint width,
gint height)
{
GdkWindowObject *private = (GdkWindowObject*) window;
GdkWindowObject *private;
GdkWindowImplWin32 *impl;
g_return_if_fail (GDK_IS_WINDOW (window));
@ -1342,6 +1300,7 @@ gdk_win32_window_move_resize_internal (GdkWindow *window,
if (height < 1)
height = 1;
private = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
if (private->state & GDK_WINDOW_STATE_FULLSCREEN)
@ -1361,7 +1320,7 @@ gdk_win32_window_move_resize_internal (GdkWindow *window,
get_outer_rect (window, width, height, &outer_rect);
adjust_for_gravity_hints (impl, &outer_rect, &x, &y);
adjust_for_gravity_hints (window, &outer_rect, &x, &y);
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%ld,%ld,"
"NOACTIVATE|NOZORDER)\n",
@ -1452,7 +1411,7 @@ gdk_win32_window_reparent (GdkWindow *window,
GDK_WINDOW_HWND (new_parent)));
API_CALL (MoveWindow, (GDK_WINDOW_HWND (window),
x, y, impl->width, impl->height, TRUE));
x, y, window_private->width, window_private->height, TRUE));
/* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
* the root window
@ -1492,7 +1451,7 @@ gdk_win32_window_reparent (GdkWindow *window,
g_list_remove (old_parent_private->children, window);
parent_private->children = g_list_prepend (parent_private->children, window);
_gdk_window_init_position (GDK_WINDOW (window_private));
//_gdk_window_init_position (GDK_WINDOW (window_private));
return FALSE;
}
@ -1513,7 +1472,7 @@ erase_background (GdkWindow *window,
if (((GdkWindowObject *) window)->input_only ||
((GdkWindowObject *) window)->bg_pixmap == GDK_NO_BG ||
GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg)
GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->no_bg)
{
return;
}
@ -1549,7 +1508,7 @@ erase_background (GdkWindow *window,
window = GDK_WINDOW (((GdkWindowObject *) window)->parent);
}
if (GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg)
if (GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->no_bg)
{
/* Improves scolling effect, e.g. main buttons of testgtk */
return;
@ -1639,8 +1598,10 @@ gdk_win32_window_clear_area (GdkWindow *window,
gboolean send_expose)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
if (!GDK_WINDOW_DESTROYED (window))
{
@ -1652,9 +1613,9 @@ gdk_win32_window_clear_area (GdkWindow *window,
if (!send_expose)
{
if (width == 0)
width = impl->width - x;
width = obj->width - x;
if (height == 0)
height = impl->height - y;
height = obj->height - y;
GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area: %p: "
"%dx%d@%+d%+d\n",
GDK_WINDOW_HWND (window),
@ -2137,39 +2098,14 @@ gdk_win32_window_set_background (GdkWindow *window,
static void
gdk_win32_window_set_back_pixmap (GdkWindow *window,
GdkPixmap *pixmap,
gint parent_relative)
GdkPixmap *pixmap)
{
GdkWindowObject *private = (GdkWindowObject *)window;
if (pixmap && !gdk_drawable_get_colormap (pixmap))
if (pixmap == GDK_PARENT_RELATIVE_BG || pixmap == GDK_NO_BG)
{
g_warning ("gdk_window_set_back_pixmap(): pixmap must have a colormap");
return;
}
if (private->bg_pixmap &&
private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
private->bg_pixmap != GDK_NO_BG)
g_object_unref (private->bg_pixmap);
if (parent_relative)
{
private->bg_pixmap = GDK_PARENT_RELATIVE_BG;
GDK_NOTE (MISC, g_print (G_STRLOC ": setting background pixmap to parent_relative\n"));
}
else
{
if (pixmap)
{
g_object_ref (pixmap);
private->bg_pixmap = pixmap;
}
else
{
private->bg_pixmap = GDK_NO_BG;
}
}
}
static void
@ -2376,14 +2312,21 @@ gdk_win32_window_get_origin (GdkWindow *window,
return return_val;
}
gboolean
gdk_window_get_deskrelative_origin (GdkWindow *window,
static gboolean
gdk_win32_window_get_deskrelative_origin (GdkWindow *window,
gint *x,
gint *y)
{
return gdk_window_get_origin (window, x, y);
}
static void
gdk_win32_window_restack_under (GdkWindow *window,
GList *native_siblings)
{
// ### TODO
}
void
gdk_window_get_root_origin (GdkWindow *window,
gint *x,
@ -2545,7 +2488,8 @@ gdk_display_warp_pointer (GdkDisplay *display,
GdkWindow*
_gdk_windowing_window_at_pointer (GdkDisplay *display,
gint *win_x,
gint *win_y)
gint *win_y,
GdkModifierType *mask)
{
GdkWindow *window;
POINT point, pointc;
@ -2665,27 +2609,6 @@ gdk_win32_window_shape_combine_mask (GdkWindow *window,
}
}
void
gdk_window_input_shape_combine_mask (GdkWindow *window,
GdkBitmap *mask,
gint x,
gint y)
{
g_return_if_fail (GDK_IS_WINDOW (window));
/* Not yet implemented
*
* I don't think there is anything in the Win32 API to directly
* support this. And anyway, as we don't currently support RGBA
* windows, it doesn't really matter.
*
* When we do support RGBA, input shape functionality could probably
* be implemented by saving the input shape region in the per-window
* private data, and then simply checking before generating an input
* event whether the event's coordinates are inside the region.
*/
}
void
gdk_window_set_override_redirect (GdkWindow *window,
gboolean override_redirect)
@ -3195,6 +3118,7 @@ gdk_win32_window_merge_child_shapes (GdkWindow *window)
gdk_propagate_shapes (GDK_WINDOW_HWND (window), TRUE);
}
#if 0
void
gdk_window_set_child_input_shapes (GdkWindow *window)
{
@ -3204,7 +3128,9 @@ gdk_window_set_child_input_shapes (GdkWindow *window)
* gdk_window_input_shape_combine_mask().
*/
}
#endif
#if 0
void
gdk_window_merge_child_input_shapes (GdkWindow *window)
{
@ -3214,6 +3140,7 @@ gdk_window_merge_child_input_shapes (GdkWindow *window)
* gdk_window_input_shape_combine_mask().
*/
}
#endif
static gboolean
gdk_win32_window_set_static_gravities (GdkWindow *window,
@ -3651,7 +3578,7 @@ gdk_window_set_skip_taskbar_hint (GdkWindow *window,
gboolean skips_taskbar)
{
static GdkWindow *owner = NULL;
GdkWindowAttr wa;
//GdkWindowAttr wa;
g_return_if_fail (GDK_IS_WINDOW (window));
@ -3664,6 +3591,7 @@ gdk_window_set_skip_taskbar_hint (GdkWindow *window,
if (skips_taskbar)
{
#if 0
if (owner == NULL)
{
wa.window_type = GDK_WINDOW_TEMP;
@ -3672,6 +3600,7 @@ gdk_window_set_skip_taskbar_hint (GdkWindow *window,
wa.event_mask = 0;
owner = gdk_window_new_internal (NULL, &wa, 0, TRUE);
}
#endif
SetWindowLongPtr (GDK_WINDOW_HWND (window), GWLP_HWNDPARENT, (LONG_PTR) GDK_WINDOW_HWND (owner));
@ -3771,19 +3700,6 @@ gdk_win32_window_shape_combine_region (GdkWindow *window,
}
}
void
gdk_window_input_shape_combine_region (GdkWindow *window,
const GdkRegion *shape_region,
gint offset_x,
gint offset_y)
{
g_return_if_fail (GDK_IS_WINDOW (window));
/* Not yet implemented. See comment in
* gdk_window_input_shape_combine_mask().
*/
}
GdkWindow *
gdk_window_lookup_for_display (GdkDisplay *display,
GdkNativeWindow anid)
@ -3849,11 +3765,78 @@ gdk_window_set_opacity (GdkWindow *window,
}
}
GdkRegion *
_gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
{
// XXX: TODO
return NULL;
}
void
_gdk_windowing_window_set_composited (GdkWindow *window, gboolean composited)
{
}
GdkRegion *
_gdk_windowing_window_get_shape (GdkWindow *window)
{
return NULL;
}
GdkRegion *
_gdk_windowing_window_get_input_shape (GdkWindow *window)
{
return NULL;
}
static void
_gdk_win32_window_destroy (GdkWindow *window,
gboolean recursing,
gboolean foreign_destroy)
{
}
static gboolean
_gdk_win32_window_queue_antiexpose (GdkWindow *window,
GdkRegion *area)
{
HRGN hrgn = _gdk_win32_gdkregion_to_hrgn (area, 0, 0);
GDK_NOTE (EVENTS, g_print ("_gdk_windowing_window_queue_antiexpose: ValidateRgn %p %s\n",
GDK_WINDOW_HWND (window),
_gdk_win32_gdkregion_to_string (area)));
ValidateRgn (GDK_WINDOW_HWND (window), hrgn);
DeleteObject (hrgn);
return FALSE;
}
static void
gdk_win32_input_shape_combine_region (GdkWindow *window,
const GdkRegion *shape_region,
gint offset_x,
gint offset_y)
{
}
void
_gdk_windowing_window_process_updates_recurse (GdkWindow *window,
GdkRegion *region)
{
}
void
_gdk_windowing_before_process_all_updates (void)
{
}
void
_gdk_windowing_after_process_all_updates (void)
{
}
static void
gdk_window_impl_iface_init (GdkWindowImplIface *iface)
{
@ -3862,22 +3845,21 @@ gdk_window_impl_iface_init (GdkWindowImplIface *iface)
iface->withdraw = gdk_win32_window_withdraw;
iface->set_events = gdk_win32_window_set_events;
iface->get_events = gdk_win32_window_get_events;
iface->clear_area = gdk_win32_window_clear_area;
iface->raise = gdk_win32_window_raise;
iface->lower = gdk_win32_window_lower;
iface->restack_under = gdk_win32_window_restack_under;
iface->move_resize = gdk_win32_window_move_resize;
iface->scroll = _gdk_win32_window_scroll;
iface->move_region = _gdk_win32_window_move_region;
iface->set_background = gdk_win32_window_set_background;
iface->set_back_pixmap = gdk_win32_window_set_back_pixmap;
iface->reparent = gdk_win32_window_reparent;
iface->set_cursor = gdk_win32_window_set_cursor;
iface->get_geometry = gdk_win32_window_get_geometry;
iface->get_origin = gdk_win32_window_get_origin;
iface->shape_combine_mask = gdk_win32_window_shape_combine_mask;
iface->shape_combine_region = gdk_win32_window_shape_combine_region;
iface->set_child_shapes = gdk_win32_window_set_child_shapes;
iface->merge_child_shapes = gdk_win32_window_merge_child_shapes;
iface->input_shape_combine_region = gdk_win32_input_shape_combine_region;
iface->get_deskrelative_origin = gdk_win32_window_get_deskrelative_origin;
iface->set_static_gravities = gdk_win32_window_set_static_gravities;
iface->get_offsets = _gdk_win32_windowing_window_get_offsets;
iface->queue_antiexpose = _gdk_win32_window_queue_antiexpose;
iface->queue_translation = NULL; //_gdk_win32_window_queue_translation;
iface->destroy = _gdk_win32_window_destroy;
}

9
gdk/win32/gdkwindow-win32.h
View File

@ -33,6 +33,7 @@ G_BEGIN_DECLS
typedef struct _GdkWin32PositionInfo GdkWin32PositionInfo;
#if 0
struct _GdkWin32PositionInfo
{
gint x;
@ -49,6 +50,7 @@ struct _GdkWin32PositionInfo
*/
GdkRectangle clip_rect; /* visible rectangle of window */
};
#endif
/* Window implementation for Win32
@ -68,11 +70,6 @@ struct _GdkWindowImplWin32
{
GdkDrawableImplWin32 parent_instance;
gint width;
gint height;
GdkWin32PositionInfo position_info;
gint8 toplevel_window_type;
HCURSOR hcursor;
@ -91,6 +88,8 @@ struct _GdkWindowImplWin32
GSList *transient_children;
gint num_transients;
gboolean changing_state;
guint no_bg : 1;
};
struct _GdkWindowImplWin32Class