From e96a41be45f82af233f5171481c3fecbe95b5b6b Mon Sep 17 00:00:00 2001 From: Tor Lillqvist Date: Tue, 12 Nov 2002 22:17:48 +0000 Subject: [PATCH] gdk/win32/gdkprivate-win32.h Rename all global variables and functions to 2002-11-12 Tor Lillqvist * gdk/win32/gdkprivate-win32.h * gdk/win32/*.c: Rename all global variables and functions to start with underscore. Merge from stable: More work on the Win32 backend. The cause of some scrolling problems was that SetWindowPos() and ScrollWindowEx() don't blit those parts of the window they think are invalid. As we didn't keep Windows's update region in synch with GDK's, Windows thought those areas that in fact had been updated were invalid. Calling ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to be an elegant and efficient solution, removing from Windows's update region those areas we are about to repaint proactively. In some cases garbage leftover values were used for the clip origin in GdkGCWin32. This showed up as odd blank areas around the pixmaps included in the Text Widget in gtk-demo. Having the clip region either as a GdkRegion or a HRGN in GdkGCWin32 was unnecessary, it's better to just use a HRGN. The translation and antiexpose queue handling in gdkgeometry-win32.c seems unnecessary (and not implementable in the same way as on X11 anyway, no serial numbers) on Windows, ifdeffed out. Don't (try to) do guffaw scrolling as there is no static window gravity on Windows. Guffaw scrolling would be unnecessary anyway, as there is the ScrollWindow() API. This improves the behaviour of the Text Widget demo in gtk-demo a lot. But I have no idea how the lack of static win gravity should be handled in other places where the X11 code uses it. Especially _gdk_window_move_resize_child(). There is still some problem in expose handling. By moving an obscuring window back and forth over testgtk's main window, for instance, every now and then you typically get narrow vertical or horizontal strips of pixels that haven't been properly redrawn after being exposed. A fencepost error somewhere? Otherwise, all of testgtk and gtk-demo except "big windows" now seem to work pretty well. Bug #79720 should be fixed now. * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, gdk_win32_print_paletteentries, gdk_win32_print_system_palette, gdk_win32_print_hpalette) * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): Move all debugging helper functions to gdkmain-win32.c. * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): Rewrite. Make static. Must take tile origin parameters, too. (gdk_win32_draw_rectangle): Pass the tile/stipple origin to _gdk_win32_draw_tiles(). Remove #if 0 code. (blit_inside_window): Don't call ScrollDC(), that didn't work at all like I thought. A simple call to BitBlt() is enough. * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused latin_locale_loaded variable. (_gdk_win32_get_next_tick): New function. Used to make sure timestamps of events are always increasing, both in events generated from the window procedure and in events gotten via PeekMessage(). Not sure whether this is actually useful, but it seemed as a good idea. (real_window_procedure): Don't use a local GdkEventPrivate variable. Don't attempt any compression of configure or expose events here, handled elsewhere. (erase_background): Accumulate window offsets when traversing up the parent chain for GDK_PARENT_RELATIVE_BG, in order to get correct alignment of background pixmaps. Don't fill with BLACK_BRUSH if GDK_NO_BG. (gdk_event_get_graphics_expose): A bit more verbose debugging output. (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the WM_PAINT handler, don't check for empty update rect. When we get a WM_PAINT, the update region isn't empty. And if it for some strange reason is, that will be handled later anyway. Call GetUpdateRgn() before calling BeginPaint() and EndPaint() (which empty the update region). * gdk/win32/gdkdnd-win32.c * gdk/win32/gdkinput-win32.c: Use _gdk_win32_get_next_tick(). * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. (gdk_text_size): Remove, unused. * gdk/win32/gdkgc-win32.c: Set clip origins to zero when appropriate. (gdk_gc_copy): Increase refcount on colormap if present. (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, combine it with clip region after selecting into the DC. (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. (_gdk_win3_gdkregion_to_hrgn): New function, code snippet extracted from gdk_win32_hdc_get(). * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue handling. (gdk_window_copy_area_scroll): Increase clipRect to avoid ScrollWindowEx() not scrolling pixels it thinks are invalid. Scroll also children with the ScrollWindowEx() call. No need to call gdk_window_move() on the children. (gdk_window_scroll): Don't do guffaw scrolling. (gdk_window_compute_position): Fix typo, used win32_y where x was intended. (gdk_window_premove, gdk_window_postmove, gdk_window_clip_changed): Add debugging output. (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() on the region. (_gdk_window_process_expose): No use for the serial number parameter now. Instead of a rectangle, take a region parameter, as Windows gives us one in WM_PAINT. * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, _gdk_win32_gdkregion_to_string): New debugging functions. (static_printf): Helper function for the above. sprintfs into a static circular buffer, return value should be used "soon". * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory leak, free list after use. (gdk_window_gravity_works): Remove, we know that there is no such thing on Windows. (gdk_window_set_static_bit_gravity, gdk_window_set_static_win_gravity): Ditto, remove, they didn't do anything anyway. (_gdk_windowing_window_init, gdk_window_foreign_new): Call _gdk_window_init_position() like in the X11 backend. (gdk_window_reparent): Don't call the now nonexistent gdk_window_set_static_win_gravity(). No idea what should be done instead. (gdk_window_get_geometry): The returned x and y should be relative to parent. Used to be always zero.. (gdk_window_set_static_gravities): Return FALSE if trying to set static gravity. * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from GdkGCWin32. Only use the HRGN hcliprgn. Declare new functions. * gdk/win32/*.c: Use new debugging functions. * gdk/win32/rc/gdk.rc.in: Update copyright year. --- ChangeLog | 175 +++++++++ ChangeLog.pre-2-10 | 175 +++++++++ ChangeLog.pre-2-2 | 175 +++++++++ ChangeLog.pre-2-4 | 175 +++++++++ ChangeLog.pre-2-6 | 175 +++++++++ ChangeLog.pre-2-8 | 175 +++++++++ gdk/win32/gdkcolor-win32.c | 94 +---- gdk/win32/gdkcursor-win32.c | 4 +- gdk/win32/gdkdnd-win32.c | 10 +- gdk/win32/gdkdrawable-win32.c | 206 ++++------ gdk/win32/gdkevents-win32.c | 620 ++++++++--------------------- gdk/win32/gdkfont-win32.c | 85 ++-- gdk/win32/gdkgc-win32.c | 447 +++++++-------------- gdk/win32/gdkgeometry-win32.c | 221 +++++++---- gdk/win32/gdkglobals-win32.c | 32 +- gdk/win32/gdkinput-win32.c | 8 +- gdk/win32/gdkmain-win32.c | 688 +++++++++++++++++++++++++++++++-- gdk/win32/gdkprivate-win32.h | 124 +++--- gdk/win32/gdkproperty-win32.c | 4 +- gdk/win32/gdkscreen-win32.c | 4 +- gdk/win32/gdkselection-win32.c | 14 +- gdk/win32/gdkvisual-win32.c | 18 +- gdk/win32/gdkwindow-win32.c | 180 +++------ gdk/win32/rc/gdk.rc.in | 2 +- 24 files changed, 2428 insertions(+), 1383 deletions(-) diff --git a/ChangeLog b/ChangeLog index 134a3e0ef3..4ea90f4706 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,178 @@ +2002-11-12 Tor Lillqvist + + * gdk/win32/gdkprivate-win32.h + * gdk/win32/*.c: Rename all global variables and functions to + start with underscore. + + Merge from stable: + + More work on the Win32 backend. The cause of some scrolling + problems was that SetWindowPos() and ScrollWindowEx() don't blit + those parts of the window they think are invalid. As we didn't + keep Windows's update region in synch with GDK's, Windows thought + those areas that in fact had been updated were invalid. Calling + ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to + be an elegant and efficient solution, removing from Windows's + update region those areas we are about to repaint proactively. + + In some cases garbage leftover values were used for the clip + origin in GdkGCWin32. This showed up as odd blank areas around the + pixmaps included in the Text Widget in gtk-demo. + + Having the clip region either as a GdkRegion or a HRGN in + GdkGCWin32 was unnecessary, it's better to just use a HRGN. + + The translation and antiexpose queue handling in + gdkgeometry-win32.c seems unnecessary (and not implementable in + the same way as on X11 anyway, no serial numbers) on Windows, + ifdeffed out. + + Don't (try to) do guffaw scrolling as there is no static window + gravity on Windows. Guffaw scrolling would be unnecessary anyway, + as there is the ScrollWindow() API. This improves the behaviour of + the Text Widget demo in gtk-demo a lot. But I have no idea how the + lack of static win gravity should be handled in other places where + the X11 code uses it. Especially _gdk_window_move_resize_child(). + + There is still some problem in expose handling. By moving an + obscuring window back and forth over testgtk's main window, for + instance, every now and then you typically get narrow vertical or + horizontal strips of pixels that haven't been properly redrawn + after being exposed. A fencepost error somewhere? + + Otherwise, all of testgtk and gtk-demo except "big windows" now + seem to work pretty well. (Well, that is in the stable branch, I + haven't really tested HEAD. Only checked that gdk/win32 compiles.) + + Bug #79720 should be fixed now. + + * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, + gdk_win32_print_paletteentries, gdk_win32_print_system_palette, + gdk_win32_print_hpalette) + * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) + * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): + Move all debugging helper functions to gdkmain-win32.c. + + * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): + Rewrite. Make static. Must take tile origin parameters, too. + + (gdk_win32_draw_rectangle): Pass the tile/stipple origin to + _gdk_win32_draw_tiles(). Remove #if 0 code. + + (blit_inside_window): Don't call ScrollDC(), that didn't work at + all like I thought. A simple call to BitBlt() is enough. + + * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused + latin_locale_loaded variable. + + (_gdk_win32_get_next_tick): New function. Used to make sure + timestamps of events are always increasing, both in events + generated from the window procedure and in events gotten via + PeekMessage(). Not sure whether this is actually useful, but it + seemed as a good idea. + + (real_window_procedure): Don't use a local GdkEventPrivate + variable. Don't attempt any compression of configure or expose + events here, handled elsewhere. + + (erase_background): Accumulate window offsets when traversing up + the parent chain for GDK_PARENT_RELATIVE_BG, in order to get + correct alignment of background pixmaps. Don't fill with + BLACK_BRUSH if GDK_NO_BG. + + (gdk_event_get_graphics_expose): A bit more verbose debugging output. + + (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the + WM_PAINT handler, don't check for empty update rect. When we get a + WM_PAINT, the update region isn't empty. And if it for some + strange reason is, that will be handled later anyway. Call + GetUpdateRgn() before calling BeginPaint() and EndPaint() (which + empty the update region). + + * gdk/win32/gdkdnd-win32.c + * gdk/win32/gdkinput-win32.c: + Use _gdk_win32_get_next_tick(). + + * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. + + (gdk_text_size): Remove, unused. + + * gdk/win32/gdkgc-win32.c: Set clip origins to zero + when appropriate. + + (gdk_gc_copy): Increase refcount on colormap if present. + + (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, + combine it with clip region after selecting into the DC. + + (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. + + (_gdk_win3_gdkregion_to_hrgn): New function, code snippet + extracted from gdk_win32_hdc_get(). + + * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue + handling. + + (gdk_window_copy_area_scroll): Increase clipRect to avoid + ScrollWindowEx() not scrolling pixels it thinks are invalid. + Scroll also children with the ScrollWindowEx() call. No need to + call gdk_window_move() on the children. + + (gdk_window_scroll): Don't do guffaw scrolling. + + (gdk_window_compute_position): Fix typo, used win32_y where x was + intended. + + (gdk_window_premove, gdk_window_postmove, + gdk_window_clip_changed): Add debugging output. + + (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() + on the region. + + (_gdk_window_process_expose): No use for the serial number + parameter now. Instead of a rectangle, take a region parameter, as + Windows gives us one in WM_PAINT. + + * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, + _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, + _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, + _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, + _gdk_win32_gdkregion_to_string): New debugging functions. + + (static_printf): Helper function for the above. sprintfs into a + static circular buffer, return value should be used "soon". + + * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory + leak, free list after use. + + (gdk_window_gravity_works): Remove, we know that there is no such + thing on Windows. + + (gdk_window_set_static_bit_gravity, + gdk_window_set_static_win_gravity): Ditto, remove, they didn't do + anything anyway. + + (_gdk_windowing_window_init, gdk_window_foreign_new): Call + _gdk_window_init_position() like in the X11 backend. + + (gdk_window_reparent): Don't call the now nonexistent + gdk_window_set_static_win_gravity(). No idea what should be done + instead. + + (gdk_window_get_geometry): The returned x and y should be relative + to parent. Used to be always zero.. + + (gdk_window_set_static_gravities): Return FALSE if trying to set + static gravity. + + * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from + GdkGCWin32. Only use the HRGN hcliprgn. Declare new + functions. + + * gdk/win32/*.c: Use new debugging functions. + + * gdk/win32/rc/gdk.rc.in: Update copyright year. + Tue Nov 12 16:51:04 2002 Owen Taylor * gtk/gtkinputdialog.c: Make multihead aware (#80283) diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index 134a3e0ef3..4ea90f4706 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,178 @@ +2002-11-12 Tor Lillqvist + + * gdk/win32/gdkprivate-win32.h + * gdk/win32/*.c: Rename all global variables and functions to + start with underscore. + + Merge from stable: + + More work on the Win32 backend. The cause of some scrolling + problems was that SetWindowPos() and ScrollWindowEx() don't blit + those parts of the window they think are invalid. As we didn't + keep Windows's update region in synch with GDK's, Windows thought + those areas that in fact had been updated were invalid. Calling + ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to + be an elegant and efficient solution, removing from Windows's + update region those areas we are about to repaint proactively. + + In some cases garbage leftover values were used for the clip + origin in GdkGCWin32. This showed up as odd blank areas around the + pixmaps included in the Text Widget in gtk-demo. + + Having the clip region either as a GdkRegion or a HRGN in + GdkGCWin32 was unnecessary, it's better to just use a HRGN. + + The translation and antiexpose queue handling in + gdkgeometry-win32.c seems unnecessary (and not implementable in + the same way as on X11 anyway, no serial numbers) on Windows, + ifdeffed out. + + Don't (try to) do guffaw scrolling as there is no static window + gravity on Windows. Guffaw scrolling would be unnecessary anyway, + as there is the ScrollWindow() API. This improves the behaviour of + the Text Widget demo in gtk-demo a lot. But I have no idea how the + lack of static win gravity should be handled in other places where + the X11 code uses it. Especially _gdk_window_move_resize_child(). + + There is still some problem in expose handling. By moving an + obscuring window back and forth over testgtk's main window, for + instance, every now and then you typically get narrow vertical or + horizontal strips of pixels that haven't been properly redrawn + after being exposed. A fencepost error somewhere? + + Otherwise, all of testgtk and gtk-demo except "big windows" now + seem to work pretty well. (Well, that is in the stable branch, I + haven't really tested HEAD. Only checked that gdk/win32 compiles.) + + Bug #79720 should be fixed now. + + * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, + gdk_win32_print_paletteentries, gdk_win32_print_system_palette, + gdk_win32_print_hpalette) + * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) + * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): + Move all debugging helper functions to gdkmain-win32.c. + + * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): + Rewrite. Make static. Must take tile origin parameters, too. + + (gdk_win32_draw_rectangle): Pass the tile/stipple origin to + _gdk_win32_draw_tiles(). Remove #if 0 code. + + (blit_inside_window): Don't call ScrollDC(), that didn't work at + all like I thought. A simple call to BitBlt() is enough. + + * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused + latin_locale_loaded variable. + + (_gdk_win32_get_next_tick): New function. Used to make sure + timestamps of events are always increasing, both in events + generated from the window procedure and in events gotten via + PeekMessage(). Not sure whether this is actually useful, but it + seemed as a good idea. + + (real_window_procedure): Don't use a local GdkEventPrivate + variable. Don't attempt any compression of configure or expose + events here, handled elsewhere. + + (erase_background): Accumulate window offsets when traversing up + the parent chain for GDK_PARENT_RELATIVE_BG, in order to get + correct alignment of background pixmaps. Don't fill with + BLACK_BRUSH if GDK_NO_BG. + + (gdk_event_get_graphics_expose): A bit more verbose debugging output. + + (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the + WM_PAINT handler, don't check for empty update rect. When we get a + WM_PAINT, the update region isn't empty. And if it for some + strange reason is, that will be handled later anyway. Call + GetUpdateRgn() before calling BeginPaint() and EndPaint() (which + empty the update region). + + * gdk/win32/gdkdnd-win32.c + * gdk/win32/gdkinput-win32.c: + Use _gdk_win32_get_next_tick(). + + * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. + + (gdk_text_size): Remove, unused. + + * gdk/win32/gdkgc-win32.c: Set clip origins to zero + when appropriate. + + (gdk_gc_copy): Increase refcount on colormap if present. + + (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, + combine it with clip region after selecting into the DC. + + (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. + + (_gdk_win3_gdkregion_to_hrgn): New function, code snippet + extracted from gdk_win32_hdc_get(). + + * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue + handling. + + (gdk_window_copy_area_scroll): Increase clipRect to avoid + ScrollWindowEx() not scrolling pixels it thinks are invalid. + Scroll also children with the ScrollWindowEx() call. No need to + call gdk_window_move() on the children. + + (gdk_window_scroll): Don't do guffaw scrolling. + + (gdk_window_compute_position): Fix typo, used win32_y where x was + intended. + + (gdk_window_premove, gdk_window_postmove, + gdk_window_clip_changed): Add debugging output. + + (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() + on the region. + + (_gdk_window_process_expose): No use for the serial number + parameter now. Instead of a rectangle, take a region parameter, as + Windows gives us one in WM_PAINT. + + * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, + _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, + _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, + _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, + _gdk_win32_gdkregion_to_string): New debugging functions. + + (static_printf): Helper function for the above. sprintfs into a + static circular buffer, return value should be used "soon". + + * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory + leak, free list after use. + + (gdk_window_gravity_works): Remove, we know that there is no such + thing on Windows. + + (gdk_window_set_static_bit_gravity, + gdk_window_set_static_win_gravity): Ditto, remove, they didn't do + anything anyway. + + (_gdk_windowing_window_init, gdk_window_foreign_new): Call + _gdk_window_init_position() like in the X11 backend. + + (gdk_window_reparent): Don't call the now nonexistent + gdk_window_set_static_win_gravity(). No idea what should be done + instead. + + (gdk_window_get_geometry): The returned x and y should be relative + to parent. Used to be always zero.. + + (gdk_window_set_static_gravities): Return FALSE if trying to set + static gravity. + + * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from + GdkGCWin32. Only use the HRGN hcliprgn. Declare new + functions. + + * gdk/win32/*.c: Use new debugging functions. + + * gdk/win32/rc/gdk.rc.in: Update copyright year. + Tue Nov 12 16:51:04 2002 Owen Taylor * gtk/gtkinputdialog.c: Make multihead aware (#80283) diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index 134a3e0ef3..4ea90f4706 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,178 @@ +2002-11-12 Tor Lillqvist + + * gdk/win32/gdkprivate-win32.h + * gdk/win32/*.c: Rename all global variables and functions to + start with underscore. + + Merge from stable: + + More work on the Win32 backend. The cause of some scrolling + problems was that SetWindowPos() and ScrollWindowEx() don't blit + those parts of the window they think are invalid. As we didn't + keep Windows's update region in synch with GDK's, Windows thought + those areas that in fact had been updated were invalid. Calling + ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to + be an elegant and efficient solution, removing from Windows's + update region those areas we are about to repaint proactively. + + In some cases garbage leftover values were used for the clip + origin in GdkGCWin32. This showed up as odd blank areas around the + pixmaps included in the Text Widget in gtk-demo. + + Having the clip region either as a GdkRegion or a HRGN in + GdkGCWin32 was unnecessary, it's better to just use a HRGN. + + The translation and antiexpose queue handling in + gdkgeometry-win32.c seems unnecessary (and not implementable in + the same way as on X11 anyway, no serial numbers) on Windows, + ifdeffed out. + + Don't (try to) do guffaw scrolling as there is no static window + gravity on Windows. Guffaw scrolling would be unnecessary anyway, + as there is the ScrollWindow() API. This improves the behaviour of + the Text Widget demo in gtk-demo a lot. But I have no idea how the + lack of static win gravity should be handled in other places where + the X11 code uses it. Especially _gdk_window_move_resize_child(). + + There is still some problem in expose handling. By moving an + obscuring window back and forth over testgtk's main window, for + instance, every now and then you typically get narrow vertical or + horizontal strips of pixels that haven't been properly redrawn + after being exposed. A fencepost error somewhere? + + Otherwise, all of testgtk and gtk-demo except "big windows" now + seem to work pretty well. (Well, that is in the stable branch, I + haven't really tested HEAD. Only checked that gdk/win32 compiles.) + + Bug #79720 should be fixed now. + + * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, + gdk_win32_print_paletteentries, gdk_win32_print_system_palette, + gdk_win32_print_hpalette) + * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) + * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): + Move all debugging helper functions to gdkmain-win32.c. + + * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): + Rewrite. Make static. Must take tile origin parameters, too. + + (gdk_win32_draw_rectangle): Pass the tile/stipple origin to + _gdk_win32_draw_tiles(). Remove #if 0 code. + + (blit_inside_window): Don't call ScrollDC(), that didn't work at + all like I thought. A simple call to BitBlt() is enough. + + * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused + latin_locale_loaded variable. + + (_gdk_win32_get_next_tick): New function. Used to make sure + timestamps of events are always increasing, both in events + generated from the window procedure and in events gotten via + PeekMessage(). Not sure whether this is actually useful, but it + seemed as a good idea. + + (real_window_procedure): Don't use a local GdkEventPrivate + variable. Don't attempt any compression of configure or expose + events here, handled elsewhere. + + (erase_background): Accumulate window offsets when traversing up + the parent chain for GDK_PARENT_RELATIVE_BG, in order to get + correct alignment of background pixmaps. Don't fill with + BLACK_BRUSH if GDK_NO_BG. + + (gdk_event_get_graphics_expose): A bit more verbose debugging output. + + (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the + WM_PAINT handler, don't check for empty update rect. When we get a + WM_PAINT, the update region isn't empty. And if it for some + strange reason is, that will be handled later anyway. Call + GetUpdateRgn() before calling BeginPaint() and EndPaint() (which + empty the update region). + + * gdk/win32/gdkdnd-win32.c + * gdk/win32/gdkinput-win32.c: + Use _gdk_win32_get_next_tick(). + + * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. + + (gdk_text_size): Remove, unused. + + * gdk/win32/gdkgc-win32.c: Set clip origins to zero + when appropriate. + + (gdk_gc_copy): Increase refcount on colormap if present. + + (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, + combine it with clip region after selecting into the DC. + + (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. + + (_gdk_win3_gdkregion_to_hrgn): New function, code snippet + extracted from gdk_win32_hdc_get(). + + * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue + handling. + + (gdk_window_copy_area_scroll): Increase clipRect to avoid + ScrollWindowEx() not scrolling pixels it thinks are invalid. + Scroll also children with the ScrollWindowEx() call. No need to + call gdk_window_move() on the children. + + (gdk_window_scroll): Don't do guffaw scrolling. + + (gdk_window_compute_position): Fix typo, used win32_y where x was + intended. + + (gdk_window_premove, gdk_window_postmove, + gdk_window_clip_changed): Add debugging output. + + (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() + on the region. + + (_gdk_window_process_expose): No use for the serial number + parameter now. Instead of a rectangle, take a region parameter, as + Windows gives us one in WM_PAINT. + + * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, + _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, + _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, + _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, + _gdk_win32_gdkregion_to_string): New debugging functions. + + (static_printf): Helper function for the above. sprintfs into a + static circular buffer, return value should be used "soon". + + * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory + leak, free list after use. + + (gdk_window_gravity_works): Remove, we know that there is no such + thing on Windows. + + (gdk_window_set_static_bit_gravity, + gdk_window_set_static_win_gravity): Ditto, remove, they didn't do + anything anyway. + + (_gdk_windowing_window_init, gdk_window_foreign_new): Call + _gdk_window_init_position() like in the X11 backend. + + (gdk_window_reparent): Don't call the now nonexistent + gdk_window_set_static_win_gravity(). No idea what should be done + instead. + + (gdk_window_get_geometry): The returned x and y should be relative + to parent. Used to be always zero.. + + (gdk_window_set_static_gravities): Return FALSE if trying to set + static gravity. + + * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from + GdkGCWin32. Only use the HRGN hcliprgn. Declare new + functions. + + * gdk/win32/*.c: Use new debugging functions. + + * gdk/win32/rc/gdk.rc.in: Update copyright year. + Tue Nov 12 16:51:04 2002 Owen Taylor * gtk/gtkinputdialog.c: Make multihead aware (#80283) diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index 134a3e0ef3..4ea90f4706 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,178 @@ +2002-11-12 Tor Lillqvist + + * gdk/win32/gdkprivate-win32.h + * gdk/win32/*.c: Rename all global variables and functions to + start with underscore. + + Merge from stable: + + More work on the Win32 backend. The cause of some scrolling + problems was that SetWindowPos() and ScrollWindowEx() don't blit + those parts of the window they think are invalid. As we didn't + keep Windows's update region in synch with GDK's, Windows thought + those areas that in fact had been updated were invalid. Calling + ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to + be an elegant and efficient solution, removing from Windows's + update region those areas we are about to repaint proactively. + + In some cases garbage leftover values were used for the clip + origin in GdkGCWin32. This showed up as odd blank areas around the + pixmaps included in the Text Widget in gtk-demo. + + Having the clip region either as a GdkRegion or a HRGN in + GdkGCWin32 was unnecessary, it's better to just use a HRGN. + + The translation and antiexpose queue handling in + gdkgeometry-win32.c seems unnecessary (and not implementable in + the same way as on X11 anyway, no serial numbers) on Windows, + ifdeffed out. + + Don't (try to) do guffaw scrolling as there is no static window + gravity on Windows. Guffaw scrolling would be unnecessary anyway, + as there is the ScrollWindow() API. This improves the behaviour of + the Text Widget demo in gtk-demo a lot. But I have no idea how the + lack of static win gravity should be handled in other places where + the X11 code uses it. Especially _gdk_window_move_resize_child(). + + There is still some problem in expose handling. By moving an + obscuring window back and forth over testgtk's main window, for + instance, every now and then you typically get narrow vertical or + horizontal strips of pixels that haven't been properly redrawn + after being exposed. A fencepost error somewhere? + + Otherwise, all of testgtk and gtk-demo except "big windows" now + seem to work pretty well. (Well, that is in the stable branch, I + haven't really tested HEAD. Only checked that gdk/win32 compiles.) + + Bug #79720 should be fixed now. + + * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, + gdk_win32_print_paletteentries, gdk_win32_print_system_palette, + gdk_win32_print_hpalette) + * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) + * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): + Move all debugging helper functions to gdkmain-win32.c. + + * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): + Rewrite. Make static. Must take tile origin parameters, too. + + (gdk_win32_draw_rectangle): Pass the tile/stipple origin to + _gdk_win32_draw_tiles(). Remove #if 0 code. + + (blit_inside_window): Don't call ScrollDC(), that didn't work at + all like I thought. A simple call to BitBlt() is enough. + + * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused + latin_locale_loaded variable. + + (_gdk_win32_get_next_tick): New function. Used to make sure + timestamps of events are always increasing, both in events + generated from the window procedure and in events gotten via + PeekMessage(). Not sure whether this is actually useful, but it + seemed as a good idea. + + (real_window_procedure): Don't use a local GdkEventPrivate + variable. Don't attempt any compression of configure or expose + events here, handled elsewhere. + + (erase_background): Accumulate window offsets when traversing up + the parent chain for GDK_PARENT_RELATIVE_BG, in order to get + correct alignment of background pixmaps. Don't fill with + BLACK_BRUSH if GDK_NO_BG. + + (gdk_event_get_graphics_expose): A bit more verbose debugging output. + + (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the + WM_PAINT handler, don't check for empty update rect. When we get a + WM_PAINT, the update region isn't empty. And if it for some + strange reason is, that will be handled later anyway. Call + GetUpdateRgn() before calling BeginPaint() and EndPaint() (which + empty the update region). + + * gdk/win32/gdkdnd-win32.c + * gdk/win32/gdkinput-win32.c: + Use _gdk_win32_get_next_tick(). + + * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. + + (gdk_text_size): Remove, unused. + + * gdk/win32/gdkgc-win32.c: Set clip origins to zero + when appropriate. + + (gdk_gc_copy): Increase refcount on colormap if present. + + (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, + combine it with clip region after selecting into the DC. + + (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. + + (_gdk_win3_gdkregion_to_hrgn): New function, code snippet + extracted from gdk_win32_hdc_get(). + + * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue + handling. + + (gdk_window_copy_area_scroll): Increase clipRect to avoid + ScrollWindowEx() not scrolling pixels it thinks are invalid. + Scroll also children with the ScrollWindowEx() call. No need to + call gdk_window_move() on the children. + + (gdk_window_scroll): Don't do guffaw scrolling. + + (gdk_window_compute_position): Fix typo, used win32_y where x was + intended. + + (gdk_window_premove, gdk_window_postmove, + gdk_window_clip_changed): Add debugging output. + + (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() + on the region. + + (_gdk_window_process_expose): No use for the serial number + parameter now. Instead of a rectangle, take a region parameter, as + Windows gives us one in WM_PAINT. + + * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, + _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, + _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, + _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, + _gdk_win32_gdkregion_to_string): New debugging functions. + + (static_printf): Helper function for the above. sprintfs into a + static circular buffer, return value should be used "soon". + + * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory + leak, free list after use. + + (gdk_window_gravity_works): Remove, we know that there is no such + thing on Windows. + + (gdk_window_set_static_bit_gravity, + gdk_window_set_static_win_gravity): Ditto, remove, they didn't do + anything anyway. + + (_gdk_windowing_window_init, gdk_window_foreign_new): Call + _gdk_window_init_position() like in the X11 backend. + + (gdk_window_reparent): Don't call the now nonexistent + gdk_window_set_static_win_gravity(). No idea what should be done + instead. + + (gdk_window_get_geometry): The returned x and y should be relative + to parent. Used to be always zero.. + + (gdk_window_set_static_gravities): Return FALSE if trying to set + static gravity. + + * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from + GdkGCWin32. Only use the HRGN hcliprgn. Declare new + functions. + + * gdk/win32/*.c: Use new debugging functions. + + * gdk/win32/rc/gdk.rc.in: Update copyright year. + Tue Nov 12 16:51:04 2002 Owen Taylor * gtk/gtkinputdialog.c: Make multihead aware (#80283) diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index 134a3e0ef3..4ea90f4706 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,178 @@ +2002-11-12 Tor Lillqvist + + * gdk/win32/gdkprivate-win32.h + * gdk/win32/*.c: Rename all global variables and functions to + start with underscore. + + Merge from stable: + + More work on the Win32 backend. The cause of some scrolling + problems was that SetWindowPos() and ScrollWindowEx() don't blit + those parts of the window they think are invalid. As we didn't + keep Windows's update region in synch with GDK's, Windows thought + those areas that in fact had been updated were invalid. Calling + ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to + be an elegant and efficient solution, removing from Windows's + update region those areas we are about to repaint proactively. + + In some cases garbage leftover values were used for the clip + origin in GdkGCWin32. This showed up as odd blank areas around the + pixmaps included in the Text Widget in gtk-demo. + + Having the clip region either as a GdkRegion or a HRGN in + GdkGCWin32 was unnecessary, it's better to just use a HRGN. + + The translation and antiexpose queue handling in + gdkgeometry-win32.c seems unnecessary (and not implementable in + the same way as on X11 anyway, no serial numbers) on Windows, + ifdeffed out. + + Don't (try to) do guffaw scrolling as there is no static window + gravity on Windows. Guffaw scrolling would be unnecessary anyway, + as there is the ScrollWindow() API. This improves the behaviour of + the Text Widget demo in gtk-demo a lot. But I have no idea how the + lack of static win gravity should be handled in other places where + the X11 code uses it. Especially _gdk_window_move_resize_child(). + + There is still some problem in expose handling. By moving an + obscuring window back and forth over testgtk's main window, for + instance, every now and then you typically get narrow vertical or + horizontal strips of pixels that haven't been properly redrawn + after being exposed. A fencepost error somewhere? + + Otherwise, all of testgtk and gtk-demo except "big windows" now + seem to work pretty well. (Well, that is in the stable branch, I + haven't really tested HEAD. Only checked that gdk/win32 compiles.) + + Bug #79720 should be fixed now. + + * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, + gdk_win32_print_paletteentries, gdk_win32_print_system_palette, + gdk_win32_print_hpalette) + * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) + * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): + Move all debugging helper functions to gdkmain-win32.c. + + * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): + Rewrite. Make static. Must take tile origin parameters, too. + + (gdk_win32_draw_rectangle): Pass the tile/stipple origin to + _gdk_win32_draw_tiles(). Remove #if 0 code. + + (blit_inside_window): Don't call ScrollDC(), that didn't work at + all like I thought. A simple call to BitBlt() is enough. + + * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused + latin_locale_loaded variable. + + (_gdk_win32_get_next_tick): New function. Used to make sure + timestamps of events are always increasing, both in events + generated from the window procedure and in events gotten via + PeekMessage(). Not sure whether this is actually useful, but it + seemed as a good idea. + + (real_window_procedure): Don't use a local GdkEventPrivate + variable. Don't attempt any compression of configure or expose + events here, handled elsewhere. + + (erase_background): Accumulate window offsets when traversing up + the parent chain for GDK_PARENT_RELATIVE_BG, in order to get + correct alignment of background pixmaps. Don't fill with + BLACK_BRUSH if GDK_NO_BG. + + (gdk_event_get_graphics_expose): A bit more verbose debugging output. + + (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the + WM_PAINT handler, don't check for empty update rect. When we get a + WM_PAINT, the update region isn't empty. And if it for some + strange reason is, that will be handled later anyway. Call + GetUpdateRgn() before calling BeginPaint() and EndPaint() (which + empty the update region). + + * gdk/win32/gdkdnd-win32.c + * gdk/win32/gdkinput-win32.c: + Use _gdk_win32_get_next_tick(). + + * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. + + (gdk_text_size): Remove, unused. + + * gdk/win32/gdkgc-win32.c: Set clip origins to zero + when appropriate. + + (gdk_gc_copy): Increase refcount on colormap if present. + + (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, + combine it with clip region after selecting into the DC. + + (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. + + (_gdk_win3_gdkregion_to_hrgn): New function, code snippet + extracted from gdk_win32_hdc_get(). + + * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue + handling. + + (gdk_window_copy_area_scroll): Increase clipRect to avoid + ScrollWindowEx() not scrolling pixels it thinks are invalid. + Scroll also children with the ScrollWindowEx() call. No need to + call gdk_window_move() on the children. + + (gdk_window_scroll): Don't do guffaw scrolling. + + (gdk_window_compute_position): Fix typo, used win32_y where x was + intended. + + (gdk_window_premove, gdk_window_postmove, + gdk_window_clip_changed): Add debugging output. + + (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() + on the region. + + (_gdk_window_process_expose): No use for the serial number + parameter now. Instead of a rectangle, take a region parameter, as + Windows gives us one in WM_PAINT. + + * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, + _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, + _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, + _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, + _gdk_win32_gdkregion_to_string): New debugging functions. + + (static_printf): Helper function for the above. sprintfs into a + static circular buffer, return value should be used "soon". + + * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory + leak, free list after use. + + (gdk_window_gravity_works): Remove, we know that there is no such + thing on Windows. + + (gdk_window_set_static_bit_gravity, + gdk_window_set_static_win_gravity): Ditto, remove, they didn't do + anything anyway. + + (_gdk_windowing_window_init, gdk_window_foreign_new): Call + _gdk_window_init_position() like in the X11 backend. + + (gdk_window_reparent): Don't call the now nonexistent + gdk_window_set_static_win_gravity(). No idea what should be done + instead. + + (gdk_window_get_geometry): The returned x and y should be relative + to parent. Used to be always zero.. + + (gdk_window_set_static_gravities): Return FALSE if trying to set + static gravity. + + * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from + GdkGCWin32. Only use the HRGN hcliprgn. Declare new + functions. + + * gdk/win32/*.c: Use new debugging functions. + + * gdk/win32/rc/gdk.rc.in: Update copyright year. + Tue Nov 12 16:51:04 2002 Owen Taylor * gtk/gtkinputdialog.c: Make multihead aware (#80283) diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index 134a3e0ef3..4ea90f4706 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,178 @@ +2002-11-12 Tor Lillqvist + + * gdk/win32/gdkprivate-win32.h + * gdk/win32/*.c: Rename all global variables and functions to + start with underscore. + + Merge from stable: + + More work on the Win32 backend. The cause of some scrolling + problems was that SetWindowPos() and ScrollWindowEx() don't blit + those parts of the window they think are invalid. As we didn't + keep Windows's update region in synch with GDK's, Windows thought + those areas that in fact had been updated were invalid. Calling + ValidateRgn() in _gdk_windowing_window_queue_antiexpose() seems to + be an elegant and efficient solution, removing from Windows's + update region those areas we are about to repaint proactively. + + In some cases garbage leftover values were used for the clip + origin in GdkGCWin32. This showed up as odd blank areas around the + pixmaps included in the Text Widget in gtk-demo. + + Having the clip region either as a GdkRegion or a HRGN in + GdkGCWin32 was unnecessary, it's better to just use a HRGN. + + The translation and antiexpose queue handling in + gdkgeometry-win32.c seems unnecessary (and not implementable in + the same way as on X11 anyway, no serial numbers) on Windows, + ifdeffed out. + + Don't (try to) do guffaw scrolling as there is no static window + gravity on Windows. Guffaw scrolling would be unnecessary anyway, + as there is the ScrollWindow() API. This improves the behaviour of + the Text Widget demo in gtk-demo a lot. But I have no idea how the + lack of static win gravity should be handled in other places where + the X11 code uses it. Especially _gdk_window_move_resize_child(). + + There is still some problem in expose handling. By moving an + obscuring window back and forth over testgtk's main window, for + instance, every now and then you typically get narrow vertical or + horizontal strips of pixels that haven't been properly redrawn + after being exposed. A fencepost error somewhere? + + Otherwise, all of testgtk and gtk-demo except "big windows" now + seem to work pretty well. (Well, that is in the stable branch, I + haven't really tested HEAD. Only checked that gdk/win32 compiles.) + + Bug #79720 should be fixed now. + + * gdk/win32/gdkcolor-win32.c (gdk_win32_color_to_string, + gdk_win32_print_paletteentries, gdk_win32_print_system_palette, + gdk_win32_print_hpalette) + * gdk/win32/gdkdrawable-win32.c (gdk_win32_drawable_description) + * gdk/win32/gdkevents-win32.c (gdk_win32_message_name): + Move all debugging helper functions to gdkmain-win32.c. + + * gdk/win32/gdkdrawable-win32.c (_gdk_win32_draw_tiles): + Rewrite. Make static. Must take tile origin parameters, too. + + (gdk_win32_draw_rectangle): Pass the tile/stipple origin to + _gdk_win32_draw_tiles(). Remove #if 0 code. + + (blit_inside_window): Don't call ScrollDC(), that didn't work at + all like I thought. A simple call to BitBlt() is enough. + + * gdk/win32/gdkevents-win32.c (gdk_event_translate) Remove unused + latin_locale_loaded variable. + + (_gdk_win32_get_next_tick): New function. Used to make sure + timestamps of events are always increasing, both in events + generated from the window procedure and in events gotten via + PeekMessage(). Not sure whether this is actually useful, but it + seemed as a good idea. + + (real_window_procedure): Don't use a local GdkEventPrivate + variable. Don't attempt any compression of configure or expose + events here, handled elsewhere. + + (erase_background): Accumulate window offsets when traversing up + the parent chain for GDK_PARENT_RELATIVE_BG, in order to get + correct alignment of background pixmaps. Don't fill with + BLACK_BRUSH if GDK_NO_BG. + + (gdk_event_get_graphics_expose): A bit more verbose debugging output. + + (gdk_event_translate): Use _gdk_win32_get_next_tick(). In the + WM_PAINT handler, don't check for empty update rect. When we get a + WM_PAINT, the update region isn't empty. And if it for some + strange reason is, that will be handled later anyway. Call + GetUpdateRgn() before calling BeginPaint() and EndPaint() (which + empty the update region). + + * gdk/win32/gdkdnd-win32.c + * gdk/win32/gdkinput-win32.c: + Use _gdk_win32_get_next_tick(). + + * gdk/win32/gdkfont-win32.c: Use %p to print HFONTs. + + (gdk_text_size): Remove, unused. + + * gdk/win32/gdkgc-win32.c: Set clip origins to zero + when appropriate. + + (gdk_gc_copy): Increase refcount on colormap if present. + + (gdk_win32_hdc_get): Handle just hcliprgn. If we have a stipple, + combine it with clip region after selecting into the DC. + + (_gdk_win32_bitmap_to_hrgn): Rename from _gdk_win32_bitmap_to_region. + + (_gdk_win3_gdkregion_to_hrgn): New function, code snippet + extracted from gdk_win32_hdc_get(). + + * gdk/win32/gdkgeometry-win32.c: Ifdef out the translate_queue + handling. + + (gdk_window_copy_area_scroll): Increase clipRect to avoid + ScrollWindowEx() not scrolling pixels it thinks are invalid. + Scroll also children with the ScrollWindowEx() call. No need to + call gdk_window_move() on the children. + + (gdk_window_scroll): Don't do guffaw scrolling. + + (gdk_window_compute_position): Fix typo, used win32_y where x was + intended. + + (gdk_window_premove, gdk_window_postmove, + gdk_window_clip_changed): Add debugging output. + + (_gdk_windowing_window_queue_antiexpose): Just call ValidateRgn() + on the region. + + (_gdk_window_process_expose): No use for the serial number + parameter now. Instead of a rectangle, take a region parameter, as + Windows gives us one in WM_PAINT. + + * gdk/win32/gdkmain-win32.c (_gdk_win32_lbstyle_to_string, + _gdk_win32_pstype_to_string, _gdk_win32_psstyle_to_string, + _gdk_win32_psendcap_to_string, _gdk_win32_psjoin_to_string, + _gdk_win32_rect_to_string, _gdk_win32_gdkrectangle_to_string, + _gdk_win32_gdkregion_to_string): New debugging functions. + + (static_printf): Helper function for the above. sprintfs into a + static circular buffer, return value should be used "soon". + + * gdk/win32/gdkwindow-win32.c (gdk_propagate_shapes): Plug memory + leak, free list after use. + + (gdk_window_gravity_works): Remove, we know that there is no such + thing on Windows. + + (gdk_window_set_static_bit_gravity, + gdk_window_set_static_win_gravity): Ditto, remove, they didn't do + anything anyway. + + (_gdk_windowing_window_init, gdk_window_foreign_new): Call + _gdk_window_init_position() like in the X11 backend. + + (gdk_window_reparent): Don't call the now nonexistent + gdk_window_set_static_win_gravity(). No idea what should be done + instead. + + (gdk_window_get_geometry): The returned x and y should be relative + to parent. Used to be always zero.. + + (gdk_window_set_static_gravities): Return FALSE if trying to set + static gravity. + + * gdk/win32/gdkprivate-win32.h: Drop the clip_region field from + GdkGCWin32. Only use the HRGN hcliprgn. Declare new + functions. + + * gdk/win32/*.c: Use new debugging functions. + + * gdk/win32/rc/gdk.rc.in: Update copyright year. + Tue Nov 12 16:51:04 2002 Owen Taylor * gtk/gtkinputdialog.c: Make multihead aware (#80283) diff --git a/gdk/win32/gdkcolor-win32.c b/gdk/win32/gdkcolor-win32.c index 9abc702184..cd0d651d50 100644 --- a/gdk/win32/gdkcolor-win32.c +++ b/gdk/win32/gdkcolor-win32.c @@ -118,92 +118,6 @@ gdk_colormap_finalize (GObject *object) G_OBJECT_CLASS (parent_class)->finalize (object); } -static gint -palette_size (HPALETTE hpal) -{ - WORD npal = 0; - - if (!GetObject (hpal, sizeof (npal), &npal)) - WIN32_GDI_FAILED ("GetObject (HPALETTE)"); - - return npal; -} - -#ifdef G_ENABLE_DEBUG - -gchar * -gdk_win32_color_to_string (const GdkColor *color) -{ - static char buf[100]; - - sprintf (buf, "(%.04x,%.04x,%.04x):%.06x", - color->red, color->green, color->blue, color->pixel); - - return buf; -} - -void -gdk_win32_print_paletteentries (const PALETTEENTRY *pep, - const int nentries) -{ - char buf[20]; - int i; - - for (i = 0; i < nentries; i++) - g_print (" %3d %02x: %02x %02x %02x%s\n", - i, i, - pep[i].peRed, pep[i].peGreen, pep[i].peBlue, - (pep[i].peFlags == 0 ? "" : - (pep[i].peFlags == PC_EXPLICIT ? " PC_EXPLICIT" : - (pep[i].peFlags == PC_NOCOLLAPSE ? " PC_NOCOLLAPSE" : - (pep[i].peFlags == PC_RESERVED ? " PC_RESERVED" : - (sprintf (buf, " %d", pep[i].peFlags), buf)))))); -} - -void -gdk_win32_print_system_palette (void) -{ - PALETTEENTRY *pe; - int k; - - k = GetSystemPaletteEntries (gdk_display_hdc, 0, 0, NULL); - pe = g_new (PALETTEENTRY, k); - k = GetSystemPaletteEntries (gdk_display_hdc, 0, k, pe); - - if (!k) - g_print ("GetSystemPaletteEntries failed: %s\n", - g_win32_error_message (GetLastError ())); - else - { - g_print ("System palette: %d entries\n", k); - gdk_win32_print_paletteentries (pe, k); - } - g_free (pe); -} - -void -gdk_win32_print_hpalette (HPALETTE hpal) -{ - PALETTEENTRY *pe; - gint n, npal; - - npal = palette_size (hpal); - pe = g_new (PALETTEENTRY, npal); - n = GetPaletteEntries (hpal, 0, npal, pe); - - if (!n) - g_print ("HPALETTE %p: GetPaletteEntries failed: %s\n", - hpal, g_win32_error_message (GetLastError ())); - else - { - g_print ("HPALETTE %p: %d (%d) entries\n", hpal, n, npal); - gdk_win32_print_paletteentries (pe, n); - } - g_free (pe); -} - -#endif - /* Mimics XAllocColorCells. Allocate read/write color cells. */ static gboolean @@ -431,7 +345,7 @@ alloc_color (GdkColormap *cmap, case GDK_VISUAL_TRUE_COLOR: /* Determine what color will actually be used on non-colormap systems. */ - *pixelp = GetNearestColor (gdk_display_hdc, new_pixel); + *pixelp = GetNearestColor (_gdk_display_hdc, new_pixel); color->peRed = GetRValue (*pixelp); color->peGreen = GetGValue (*pixelp); color->peBlue = GetBValue (*pixelp); @@ -502,7 +416,7 @@ free_colors (GdkColormap *cmap, } } #if 0 - GDK_NOTE (COLORMAP, gdk_win32_print_hpalette (cmapp->hpal)); + GDK_NOTE (COLORMAP, _gdk_win32_print_hpalette (cmapp->hpal)); #else GDK_NOTE (COLORMAP, (set_black_count > 0 ? g_print ("free_colors: %d (%d) set to black\n", @@ -550,7 +464,7 @@ create_colormap (GdkColormap *cmap, lp.pal.palPalEntry[i].peFlags = 0; GDK_NOTE (COLORMAP, (g_print ("Default palette %p: %d entries\n", hpal, lp.pal.palNumEntries), - gdk_win32_print_paletteentries (lp.pal.palPalEntry, + _gdk_win32_print_paletteentries (lp.pal.palPalEntry, lp.pal.palNumEntries))); DeleteObject (hpal); @@ -604,7 +518,7 @@ sync_colors (GdkColormap *colormap) GDK_NOTE (COLORMAP, (g_print ("sync_colors: %p hpal=%p: %d entries\n", private, private->hpal, nlookup), - gdk_win32_print_paletteentries (pe, nlookup))); + _gdk_win32_print_paletteentries (pe, nlookup))); for (i = 0; i < nlookup; i++) { diff --git a/gdk/win32/gdkcursor-win32.c b/gdk/win32/gdkcursor-win32.c index 723b9a3ede..c4918a5f52 100644 --- a/gdk/win32/gdkcursor-win32.c +++ b/gdk/win32/gdkcursor-win32.c @@ -73,7 +73,7 @@ _gdk_win32_data_to_wcursor (GdkCursorType cursor_type) #undef SET_BIT #undef RESET_BIT - rv = CreateCursor (gdk_app_hmodule, cursors[i].hotx, cursors[i].hoty, + rv = CreateCursor (_gdk_app_hmodule, cursors[i].hotx, cursors[i].hoty, w, h, and_plane, xor_plane); if (rv == NULL) WIN32_API_FAILED ("CreateCursor"); @@ -264,7 +264,7 @@ gdk_cursor_new_from_pixmap (GdkPixmap *source, q[-1] |= residue; /* Set left-over bits */ } - hcursor = CreateCursor (gdk_app_hmodule, x, y, cursor_width, cursor_height, + hcursor = CreateCursor (_gdk_app_hmodule, x, y, cursor_width, cursor_height, and_mask, xor_mask); GDK_NOTE (MISC, g_print ("gdk_cursor_new_from_pixmap: " diff --git a/gdk/win32/gdkdnd-win32.c b/gdk/win32/gdkdnd-win32.c index c006f7f729..08cdcdef3e 100644 --- a/gdk/win32/gdkdnd-win32.c +++ b/gdk/win32/gdkdnd-win32.c @@ -965,7 +965,7 @@ gdk_dropfiles_filter (GdkXEvent *xev, gdk_drawable_ref (context->dest_window); /* WM_DROPFILES drops are always file names */ context->targets = - g_list_append (NULL, GUINT_TO_POINTER (text_uri_list)); + g_list_append (NULL, GUINT_TO_POINTER (_text_uri_list)); current_dest_drag = context; event->dnd.type = GDK_DROP_START; @@ -977,7 +977,7 @@ gdk_dropfiles_filter (GdkXEvent *xev, event->dnd.x_root = pt.x; event->dnd.y_root = pt.y; - event->dnd.time = msg->time; + event->dnd.time = _gdk_win32_get_next_tick (msg->time); nfiles = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0); @@ -1675,11 +1675,11 @@ GdkAtom gdk_drag_get_selection (GdkDragContext *context) { if (context->protocol == GDK_DRAG_PROTO_LOCAL) - return local_dnd; + return _local_dnd; else if (context->protocol == GDK_DRAG_PROTO_WIN32_DROPFILES) - return gdk_win32_dropfiles; + return _gdk_win32_dropfiles; else if (context->protocol == GDK_DRAG_PROTO_OLE2) - return gdk_ole2_dnd; + return _gdk_ole2_dnd; else return GDK_NONE; } diff --git a/gdk/win32/gdkdrawable-win32.c b/gdk/win32/gdkdrawable-win32.c index 26a7c73e23..fa15224146 100644 --- a/gdk/win32/gdkdrawable-win32.c +++ b/gdk/win32/gdkdrawable-win32.c @@ -123,39 +123,6 @@ static void gdk_drawable_impl_win32_finalize (GObject *object); static gpointer parent_class = NULL; -#ifdef G_ENABLE_DEBUG - -gchar * -gdk_win32_drawable_description (GdkDrawable *d) -{ - GdkVisual *v; - static gchar buf[1000]; - static gchar *bufp = buf; - gchar *msg; - gint width, height; - gchar *retval; - - gdk_drawable_get_size (d, &width, &height); - msg = g_strdup_printf - ("%s:%p:%dx%dx%d", - G_OBJECT_TYPE_NAME (d), - GDK_DRAWABLE_HANDLE (d), - width, height, - (GDK_IS_PIXMAP (d) ? GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (d)->impl)->image->depth - : ((v = gdk_drawable_get_visual (d)) ? v->depth : gdk_visual_get_system ()->depth))); - - if (bufp + strlen (msg) + 1 > buf + sizeof (buf)) - bufp = buf; - retval = bufp; - strcpy (bufp, msg); - bufp += strlen (msg) + 1; - g_free (msg); - - return retval; -} - -#endif - GType gdk_drawable_impl_win32_get_type (void) { @@ -322,6 +289,59 @@ render_line_vertical (HDC hdc, return TRUE; } +static void +_gdk_win32_draw_tiles (GdkDrawable *drawable, + GdkGC *gc, + GdkPixmap *tile, + gint dest_x, + gint dest_y, + gint tile_x_origin, + gint tile_y_origin, + gint width, + gint height) +{ + gint x, y; + gint tile_width, tile_height; + + GDK_NOTE (MISC, g_print ("_gdk_win32_draw_tiles: %s +%d+%d tile=%s@+%d+%d %dx%d\n", + _gdk_win32_drawable_description (drawable), + dest_x, dest_y, + _gdk_win32_drawable_description (tile), + tile_x_origin, tile_y_origin, + width, height)); + + gdk_drawable_get_size (tile, &tile_width, &tile_height); + + y = tile_y_origin % tile_height; + if (y > 0) + y -= tile_height; + while (y < dest_y + height) + { + if (y + tile_height >= dest_y) + { + x = tile_x_origin % tile_width; + if (x > 0) + x -= tile_width; + while (x < dest_x + width) + { + if (x + tile_width >= dest_x) + { + gint src_x = MAX (0, dest_x - x); + gint src_y = MAX (0, dest_y - y); + + gdk_draw_drawable (drawable, gc, tile, + src_x, src_y, + x + src_x, y + src_y, + MIN (tile_width, dest_x + width - (x + src_x)), + MIN (tile_height, dest_y + height - (y + src_y))); + } + x += tile_width; + } + } + y += tile_height; + } +} + static void gdk_win32_draw_rectangle (GdkDrawable *drawable, GdkGC *gc, @@ -339,41 +359,27 @@ gdk_win32_draw_rectangle (GdkDrawable *drawable, gboolean ok = TRUE; GDK_NOTE (MISC, g_print ("gdk_win32_draw_rectangle: %s (%p) %s%dx%d@+%d+%d\n", - gdk_win32_drawable_description (drawable), + _gdk_win32_drawable_description (drawable), gc_private, (filled ? "fill " : ""), width, height, x, y)); if (filled - && (gc_private->tile) && (gc_private->values_mask & GDK_GC_TILE) - && (gc_private->values_mask & GDK_GC_FILL)) + && (gc_private->tile) + && (gc_private->values_mask & GDK_GC_FILL) + && (gc_private->fill_style == GDK_TILED)) { - _gdk_win32_draw_tiles (drawable, gc, gc_private->tile, x, y, width, height); + _gdk_win32_draw_tiles (drawable, gc, gc_private->tile, + x, y, + gc->ts_x_origin, + gc->ts_y_origin, + width, height); return; } hdc = gdk_win32_hdc_get (drawable, gc, mask); -#if 0 - { - HBRUSH hbr = GetCurrentObject (hdc, OBJ_BRUSH); - HPEN hpen = GetCurrentObject (hdc, OBJ_PEN); - LOGBRUSH lbr; - LOGPEN lpen; - GetObject (hbr, sizeof (lbr), &lbr); - GetObject (hpen, sizeof (lpen), &lpen); - - g_print ("current brush: style = %s, color = 0x%.08x\n", - (lbr.lbStyle == BS_SOLID ? "SOLID" : "???"), - lbr.lbColor); - g_print ("current pen: style = %s, width = %d, color = 0x%.08x\n", - (lpen.lopnStyle == PS_SOLID ? "SOLID" : "???"), - lpen.lopnWidth, - lpen.lopnColor); - } -#endif - if (gc_private->fill_style == GDK_OPAQUE_STIPPLED) { if (!BeginPath (hdc)) @@ -466,7 +472,7 @@ gdk_win32_draw_arc (GdkDrawable *drawable, int nXStartArc, nYStartArc, nXEndArc, nYEndArc; GDK_NOTE (MISC, g_print ("gdk_draw_arc: %s %d,%d,%d,%d %d %d\n", - gdk_win32_drawable_description (drawable), + _gdk_win32_drawable_description (drawable), x, y, width, height, angle1, angle2)); /* Seems that drawing arcs with width or height <= 2 fails, at least @@ -537,7 +543,7 @@ gdk_win32_draw_polygon (GdkDrawable *drawable, int i; GDK_NOTE (MISC, g_print ("gdk_win32_draw_polygon: %s (%p) %d\n", - gdk_win32_drawable_description (drawable), + _gdk_win32_drawable_description (drawable), gc_private, npoints)); @@ -662,7 +668,7 @@ gdk_win32_draw_text (GdkDrawable *drawable, arg.hdc = gdk_win32_hdc_get (drawable, gc, mask); GDK_NOTE (MISC, g_print ("gdk_draw_text: %s (%d,%d) \"%.*s\" (len %d)\n", - gdk_win32_drawable_description (drawable), + _gdk_win32_drawable_description (drawable), x, y, (text_length > 10 ? 10 : text_length), text, text_length)); @@ -711,7 +717,7 @@ gdk_win32_draw_text_wc (GdkDrawable *drawable, arg.hdc = gdk_win32_hdc_get (drawable, gc, mask); GDK_NOTE (MISC, g_print ("gdk_draw_text_wc: %s (%d,%d) len: %d\n", - gdk_win32_drawable_description (drawable), + _gdk_win32_drawable_description (drawable), x, y, text_length)); if (sizeof (wchar_t) != sizeof (GdkWChar)) @@ -750,49 +756,6 @@ gdk_win32_draw_drawable (GdkDrawable *drawable, xdest, ydest, width, height); } -void -_gdk_win32_draw_tiles (GdkDrawable *drawable, - GdkGC *gc, - GdkPixmap *tile, - gint x_from, - gint y_from, - gint max_width, - gint max_height) -{ - gint x = x_from, y = y_from; - gint tile_width, tile_height; - gint width, height; - - GDK_NOTE (MISC, g_print ("_gdk_win32_draw_tiles: %s tile=%s +%d+%d %d,%d\n", - gdk_win32_drawable_description (drawable), - gdk_win32_drawable_description (tile), - x_from, y_from, max_width, max_height)); - - gdk_drawable_get_size (drawable, &width, &height); - gdk_drawable_get_size (tile, &tile_width, &tile_height); - - width = MIN (width, max_width); - height = MIN (height, max_height); - - tile_width = MIN (tile_width, max_width); - tile_height = MIN (tile_height, max_height); - - while (y < height) - { - x = x_from; - while (x < width) - { - gdk_draw_drawable (drawable, gc, tile, - x % tile_width, /* xsrc */ - y % tile_height, /* ysrc */ - x, y, /* dest */ - tile_width, tile_height); - x += tile_width; - } - y += tile_height; - } -} - static void gdk_win32_draw_points (GdkDrawable *drawable, GdkGC *gc, @@ -810,7 +773,7 @@ gdk_win32_draw_points (GdkDrawable *drawable, fg = _gdk_win32_colormap_color (impl->colormap, gc_private->foreground); GDK_NOTE (MISC, g_print ("gdk_draw_points: %s %dx%.06x\n", - gdk_win32_drawable_description (drawable), + _gdk_win32_drawable_description (drawable), npoints, (guint) fg)); for (i = 0; i < npoints; i++) @@ -832,7 +795,7 @@ gdk_win32_draw_segments (GdkDrawable *drawable, int i; GDK_NOTE (MISC, g_print ("gdk_win32_draw_segments: %s nsegs: %d\n", - gdk_win32_drawable_description (drawable), nsegs)); + _gdk_win32_drawable_description (drawable), nsegs)); hdc = gdk_win32_hdc_get (drawable, gc, mask); @@ -1235,34 +1198,11 @@ blit_inside_window (GdkDrawableImplWin32 *window, gint height) { - RECT scrollRect, clipRect, emptyRect; - HRGN updateRgn; - GDK_NOTE (MISC, g_print ("blit_inside_window\n")); - scrollRect.left = MIN (xsrc, xdest); - scrollRect.top = MIN (ysrc, ydest); - scrollRect.right = MAX (xsrc + width + 1, xdest + width + 1); - scrollRect.bottom = MAX (ysrc + height + 1, ydest + height + 1); - - clipRect.left = xdest; - clipRect.top = ydest; - clipRect.right = xdest + width + 1; - clipRect.bottom = ydest + height + 1; - - SetRectEmpty (&emptyRect); - updateRgn = CreateRectRgnIndirect (&emptyRect); - if (!ScrollDC (hdc, xdest - xsrc, ydest - ysrc, - &scrollRect, &clipRect, - updateRgn, NULL)) - WIN32_GDI_FAILED ("ScrollDC"); - else if (!InvalidateRgn (window->handle, updateRgn, FALSE)) - WIN32_GDI_FAILED ("InvalidateRgn"); - else if (!UpdateWindow (window->handle)) - WIN32_GDI_FAILED ("UpdateWindow"); - - if (!DeleteObject (updateRgn)) - WIN32_GDI_FAILED ("DeleteObject"); + if (!BitBlt (hdc, xdest, ydest, width, height, + hdc, xsrc, ysrc, SRCCOPY)) + WIN32_GDI_FAILED ("BitBlt"); } static void @@ -1333,9 +1273,9 @@ _gdk_win32_blit (gboolean use_fg_bg, GDK_NOTE (MISC, g_print ("_gdk_win32_blit: src:%s %dx%d@+%d+%d\n" " dst:%s @+%d+%d use_fg_bg=%d\n", - gdk_win32_drawable_description (src), + _gdk_win32_drawable_description (src), width, height, xsrc, ysrc, - gdk_win32_drawable_description ((GdkDrawable *) drawable), + _gdk_win32_drawable_description ((GdkDrawable *) drawable), xdest, ydest, use_fg_bg)); diff --git a/gdk/win32/gdkevents-win32.c b/gdk/win32/gdkevents-win32.c index cc5589b3e3..079896b9e0 100644 --- a/gdk/win32/gdkevents-win32.c +++ b/gdk/win32/gdkevents-win32.c @@ -136,7 +136,19 @@ static PFN_TrackMouseEvent track_mouse_event = NULL; static gboolean use_ime_composition = FALSE; static HKL latin_locale = NULL; -static gboolean latin_locale_loaded = FALSE; + +gulong +_gdk_win32_get_next_tick (gulong suggested_tick) +{ + static gulong cur_tick = 0; + + if (suggested_tick == 0) + suggested_tick = GetTickCount (); + if (suggested_tick <= cur_tick) + return ++cur_tick; + else + return cur_tick = suggested_tick; +} static LRESULT real_window_procedure (HWND hwnd, @@ -146,8 +158,7 @@ real_window_procedure (HWND hwnd, { /* any way to have more than one display on win32 ? */ GdkDisplay *display = gdk_display_get_default (); - GdkEventPrivate event; - GdkEvent *eventp; + GdkEvent *event; MSG msg; DWORD pos; #ifdef HAVE_DIMM_H @@ -160,66 +171,16 @@ real_window_procedure (HWND hwnd, msg.message = message; msg.wParam = wparam; msg.lParam = lparam; - msg.time = GetTickCount (); + msg.time = _gdk_win32_get_next_tick (0); pos = GetMessagePos (); msg.pt.x = LOWORD (pos); msg.pt.y = HIWORD (pos); - event.flags = GDK_EVENT_PENDING; - event.screen = NULL; - if (gdk_event_translate (display, &event.event, &msg, &ret_val_flag, &ret_val, FALSE)) + event = gdk_event_new (GDK_NOTHING); + ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING; + if (gdk_event_translate (display, event, &msg, &ret_val_flag, &ret_val, FALSE)) { - event.flags &= ~GDK_EVENT_PENDING; -#if 1 - if (event.event.any.type == GDK_CONFIGURE) - { - /* Compress configure events */ - GList *list = display->queued_events; - - while (list != NULL - && (((GdkEvent *)list->data)->any.type != GDK_CONFIGURE - || ((GdkEvent *)list->data)->any.window != event.event.any.window)) - list = list->next; - if (list != NULL) - { - GDK_NOTE (EVENTS, g_print ("... compressing an CONFIGURE event\n")); - - *((GdkEvent *)list->data) = event.event; - gdk_drawable_unref (event.event.any.window); - /* Wake up WaitMessage */ - PostMessage (NULL, gdk_ping_msg, 0, 0); - return FALSE; - } - } - else if (event.event.any.type == GDK_EXPOSE) - { - /* Compress expose events */ - GList *list = display->queued_events; - - while (list != NULL - && (((GdkEvent *)list->data)->any.type != GDK_EXPOSE - || ((GdkEvent *)list->data)->any.window != event.event.any.window)) - list = list->next; - if (list != NULL) - { - GdkRectangle u; - - GDK_NOTE (EVENTS, g_print ("... compressing an EXPOSE event\n")); - gdk_rectangle_union (&event.event.expose.area, - &((GdkEvent *)list->data)->expose.area, - &u); - ((GdkEvent *)list->data)->expose.area = u; - gdk_drawable_unref (event.event.any.window); -#if 0 - /* Wake up WaitMessage */ - PostMessage (NULL, gdk_ping_msg, 0, 0); -#endif - return FALSE; - } - } -#endif - eventp = gdk_event_new (GDK_NOTHING); - *((GdkEventPrivate *) eventp) = event; + ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING; /* Philippe Colantoni suggests this * in order to handle events while opaque resizing neatly. I @@ -227,21 +188,21 @@ real_window_procedure (HWND hwnd, * GDK_EVENT_FUNC_FROM_WINDOW_PROC env var to get this * behaviour. */ - if (gdk_event_func_from_window_proc && _gdk_event_func) + if (_gdk_event_func_from_window_proc && _gdk_event_func) { GDK_THREADS_ENTER (); - (*_gdk_event_func) (eventp, _gdk_event_data); - gdk_event_free (eventp); + (*_gdk_event_func) (event, _gdk_event_data); + gdk_event_free (event); GDK_THREADS_LEAVE (); } else { - _gdk_event_queue_append (display, eventp); + _gdk_event_queue_append (display, event); - if (eventp->type == GDK_BUTTON_PRESS) - _gdk_event_button_generate (display, eventp); + if (event->type == GDK_BUTTON_PRESS) + _gdk_event_button_generate (display, event); #if 1 /* Wake up WaitMessage */ PostMessage (NULL, gdk_ping_msg, 0, 0); @@ -253,6 +214,8 @@ real_window_procedure (HWND hwnd, else return FALSE; } + else + gdk_event_free (event); if (ret_val_flag) return ret_val; @@ -279,12 +242,12 @@ _gdk_win32_window_procedure (HWND hwnd, LRESULT retval; GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %p %s\n", - hwnd, gdk_win32_message_name (message))); + hwnd, _gdk_win32_message_to_string (message))); retval = real_window_procedure (hwnd, message, wparam, lparam); - GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %p returns %ld\n", - hwnd, retval)); + GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %p %s return %ld\n", + hwnd, _gdk_win32_message_to_string (message), retval)); return retval; } @@ -383,8 +346,6 @@ _gdk_events_init (void) char id[9]; sprintf (id, "%08x", MAKELANGID (latin_languages[i++], SUBLANG_DEFAULT)); latin_locale = LoadKeyboardLayout (id, KLF_NOTELLSHELL|KLF_SUBSTITUTE_OK); - if (latin_locale != NULL) - latin_locale_loaded = TRUE; } } @@ -437,7 +398,7 @@ _gdk_events_init (void) if (track_mouse_event != NULL) GDK_NOTE (EVENTS, g_print ("Using TrackMouseEvent to detect leave events\n")); #endif - if (IS_WIN_NT () && (windows_version & 0xFF) == 5) + if (IS_WIN_NT () && (_windows_version & 0xFF) == 5) { /* On Win2k (Beta 3, at least) WM_IME_CHAR doesn't seem to work * correctly for non-Unicode applications. Handle @@ -510,11 +471,15 @@ gdk_event_get_graphics_expose (GdkWindow *window) if (gdk_event_translate (gdk_drawable_get_display (window), event, &msg, NULL, NULL, TRUE)) - return event; + { + GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose: got it!\n")); + return event; + } else gdk_event_free (event); } + GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose: nope\n")); return NULL; #endif } @@ -529,27 +494,27 @@ event_mask_string (GdkEventMask mask) #define BIT(x) \ if (mask & GDK_##x##_MASK) \ p += sprintf (p, "%s" #x, (p > bfr ? " " : "")) - BIT(EXPOSURE); - BIT(POINTER_MOTION); - BIT(POINTER_MOTION_HINT); - BIT(BUTTON_MOTION); - BIT(BUTTON1_MOTION); - BIT(BUTTON2_MOTION); - BIT(BUTTON3_MOTION); - BIT(BUTTON_PRESS); - BIT(BUTTON_RELEASE); - BIT(KEY_PRESS); - BIT(KEY_RELEASE); - BIT(ENTER_NOTIFY); - BIT(LEAVE_NOTIFY); - BIT(FOCUS_CHANGE); - BIT(STRUCTURE); - BIT(PROPERTY_CHANGE); - BIT(VISIBILITY_NOTIFY); - BIT(PROXIMITY_IN); - BIT(PROXIMITY_OUT); - BIT(SUBSTRUCTURE); - BIT(SCROLL); + BIT (EXPOSURE); + BIT (POINTER_MOTION); + BIT (POINTER_MOTION_HINT); + BIT (BUTTON_MOTION); + BIT (BUTTON1_MOTION); + BIT (BUTTON2_MOTION); + BIT (BUTTON3_MOTION); + BIT (BUTTON_PRESS); + BIT (BUTTON_RELEASE); + BIT (KEY_PRESS); + BIT (KEY_RELEASE); + BIT (ENTER_NOTIFY); + BIT (LEAVE_NOTIFY); + BIT (FOCUS_CHANGE); + BIT (STRUCTURE); + BIT (PROPERTY_CHANGE); + BIT (VISIBILITY_NOTIFY); + BIT (PROXIMITY_IN); + BIT (PROXIMITY_OUT); + BIT (SUBSTRUCTURE); + BIT (SCROLL); #undef BIT return bfr; @@ -941,7 +906,7 @@ build_keypress_event (GdkEvent *event, wchar_t wbuf[100]; event->key.type = GDK_KEY_PRESS; - event->key.time = msg->time; + event->key.time = _gdk_win32_get_next_tick (msg->time); event->key.state = 0; event->key.group = 0; /* ??? */ event->key.keyval = GDK_VoidSymbol; @@ -1033,12 +998,13 @@ build_keyrelease_event (GdkEvent *event, wchar_t wbuf; event->key.type = GDK_KEY_RELEASE; - event->key.time = msg->time; + event->key.time = _gdk_win32_get_next_tick (msg->time); event->key.state = 0; event->key.group = 0; /* ??? */ if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR) { + event->key.hardware_keycode = vk_from_char (msg->wParam); if (msg->wParam < ' ') { event->key.keyval = msg->wParam + '@'; @@ -1052,7 +1018,6 @@ build_keyrelease_event (GdkEvent *event, event->key.keyval = gdk_unicode_to_keyval (wbuf); } - event->key.hardware_keycode = vk_from_char (msg->wParam); } else { @@ -1145,11 +1110,8 @@ print_event (GdkEvent *event) switch (event->any.type) { case GDK_EXPOSE: - g_print ("%dx%d@+%d+%d %d", - event->expose.area.width, - event->expose.area.height, - event->expose.area.x, - event->expose.area.y, + g_print ("%s %d", + _gdk_win32_gdkrectangle_to_string (&event->expose.area), event->expose.count); break; case GDK_MOTION_NOTIFY: @@ -1240,7 +1202,7 @@ synthesize_enter_or_leave_event (GdkWindow *window, event->crossing.send_event = FALSE; gdk_window_ref (event->crossing.window); event->crossing.subwindow = NULL; - event->crossing.time = msg->time; + event->crossing.time = _gdk_win32_get_next_tick (msg->time); event->crossing.x = x; event->crossing.y = y; event->crossing.x_root = msg->pt.x; @@ -1720,12 +1682,18 @@ erase_background (GdkWindow *window, COLORREF bg; GdkColormap *colormap; GdkColormapPrivateWin32 *colormap_private; - int i, j; + int x, y; + int x_offset, y_offset; - if (GDK_WINDOW_OBJECT (window)->input_only || - GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_NO_BG || - GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg) - return; + if (((GdkWindowObject *) window)->input_only || + ((GdkWindowObject *) window)->bg_pixmap == GDK_NO_BG || + GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg) + { + GDK_NOTE (EVENTS, g_print (((GdkWindowObject *) window)->input_only ? "...input_only\n" : + ((GdkWindowObject *) window)->bg_pixmap == GDK_NO_BG ? "GDK_NO_BG" : + GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg ? "no_bg\n" : "???\n")); + return; + } colormap = gdk_drawable_get_colormap (window); @@ -1742,37 +1710,44 @@ erase_background (GdkWindow *window, else if ((k = RealizePalette (hdc)) == GDI_ERROR) WIN32_GDI_FAILED ("RealizePalette"); else if (k > 0) - GDK_NOTE (COLORMAP, g_print ("gdk_win32_erase_background: realized %p: %d colors\n", + GDK_NOTE (COLORMAP, g_print ("erase_background: realized %p: %d colors\n", colormap_private->hpal, k)); } - while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG) + x_offset = y_offset = 0; + while (window && ((GdkWindowObject *) window)->bg_pixmap == GDK_PARENT_RELATIVE_BG) { /* If this window should have the same background as the parent, * fetch the parent. (And if the same goes for the parent, fetch * the grandparent, etc.) */ - window = GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent); + x_offset += ((GdkWindowObject *) window)->x; + y_offset += ((GdkWindowObject *) window)->y; + window = GDK_WINDOW (((GdkWindowObject *) window)->parent); } - if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg) + if (GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg) { + GDK_NOTE (EVENTS, g_print ("no_bg on ancestor (?)\n")); /* Improves scolling effect, e.g. main buttons of testgtk */ return; } - if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL) + GetClipBox (hdc, &rect); + + GDK_NOTE (EVENTS, (hbr = GetStockObject (BLACK_BRUSH), + FillRect (hdc, &rect, hbr), + GdiFlush (), + Sleep (200))); + + if (((GdkWindowObject *) window)->bg_pixmap == NULL) { - bg = _gdk_win32_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap, - GDK_WINDOW_OBJECT (window)->bg_color.pixel); + bg = _gdk_win32_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->colormap, + ((GdkWindowObject *) window)->bg_color.pixel); - GetClipBox (hdc, &rect); - GDK_NOTE (EVENTS, - g_print ("...%ldx%ld@+%ld+%ld bg %06lx\n", - rect.right - rect.left, - rect.bottom - rect.top, - rect.left, rect.top, - (gulong) bg)); + GDK_NOTE (EVENTS, g_print ("...%s bg %06lx\n", + _gdk_win32_rect_to_string (&rect), + (gulong) bg)); if (!(hbr = CreateSolidBrush (bg))) WIN32_GDI_FAILED ("CreateSolidBrush"); else if (!FillRect (hdc, &rect, hbr)) @@ -1780,15 +1755,13 @@ erase_background (GdkWindow *window, if (hbr != NULL) DeleteObject (hbr); } - else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL && - GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG) + else if (((GdkWindowObject *) window)->bg_pixmap != GDK_NO_BG) { - GdkPixmap *pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap; + GdkPixmap *pixmap = ((GdkWindowObject *) window)->bg_pixmap; GdkPixmapImplWin32 *pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl); - GetClipBox (hdc, &rect); - - if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8) + if (x_offset == 0 && y_offset == 0 && + pixmap_impl->width <= 8 && pixmap_impl->height <= 8) { GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n")); if (!(hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap)))) @@ -1804,12 +1777,10 @@ erase_background (GdkWindow *window, GDK_NOTE (EVENTS, g_print ("...blitting pixmap %p (%dx%d) " - "all over the place,\n" - "...clip box = %ldx%ld@+%ld+%ld\n", + " clip box = %s\n", GDK_PIXMAP_HBITMAP (pixmap), pixmap_impl->width, pixmap_impl->height, - rect.right - rect.left, rect.bottom - rect.top, - rect.left, rect.top)); + _gdk_win32_rect_to_string (&rect))); if (!(bgdc = CreateCompatibleDC (hdc))) { @@ -1822,41 +1793,35 @@ erase_background (GdkWindow *window, DeleteDC (bgdc); return; } - i = 0; - while (i < rect.right) + x = -x_offset; + while (x < rect.right) { - j = 0; - while (j < rect.bottom) + if (x + pixmap_impl->width >= rect.left) { - if (i + pixmap_impl->width >= rect.left - && j + pixmap_impl->height >= rect.top) + y = -y_offset; + while (y < rect.bottom) { - if (!BitBlt (hdc, i, j, - pixmap_impl->width, pixmap_impl->height, - bgdc, 0, 0, SRCCOPY)) + if (y + pixmap_impl->height >= rect.top) { - WIN32_GDI_FAILED ("BitBlt"); - SelectObject (bgdc, oldbitmap); - DeleteDC (bgdc); - return; + if (!BitBlt (hdc, x, y, + pixmap_impl->width, pixmap_impl->height, + bgdc, 0, 0, SRCCOPY)) + { + WIN32_GDI_FAILED ("BitBlt"); + SelectObject (bgdc, oldbitmap); + DeleteDC (bgdc); + return; + } } + y += pixmap_impl->height; } - j += pixmap_impl->height; } - i += pixmap_impl->width; + x += pixmap_impl->width; } SelectObject (bgdc, oldbitmap); DeleteDC (bgdc); } } - else - { - GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n")); - hbr = GetStockObject (BLACK_BRUSH); - GetClipBox (hdc, &rect); - if (!FillRect (hdc, &rect, hbr)) - WIN32_GDI_FAILED ("FillRect"); - } } static GdkRegion * @@ -1939,7 +1904,6 @@ gdk_event_translate (GdkDisplay *display, static gint update_colors_counter = 0; gint button; - gint k; gchar buf[256]; gboolean return_val = FALSE; @@ -1974,10 +1938,10 @@ gdk_event_translate (GdkDisplay *display, * removed it. Repost the same message to our queue so that * we will get it later when we are prepared. */ - GDK_NOTE (MISC, g_print("gdk_event_translate: %p %s posted.\n", - msg->hwnd, - msg->message == WM_MOVE ? - "WM_MOVE" : "WM_SIZE")); + GDK_NOTE (MISC, g_print ("gdk_event_translate: %p %s posted.\n", + msg->hwnd, + msg->message == WM_MOVE ? + "WM_MOVE" : "WM_SIZE")); PostMessage (msg->hwnd, msg->message, msg->wParam, msg->lParam); @@ -2002,7 +1966,7 @@ gdk_event_translate (GdkDisplay *display, else { GDK_NOTE (EVENTS, g_print ("gdk_event_translate: %s for %p (NULL)\n", - gdk_win32_message_name(msg->message), + _gdk_win32_message_to_string (msg->message), msg->hwnd)); } #endif @@ -2076,7 +2040,7 @@ gdk_event_translate (GdkDisplay *display, event->scroll.direction = ((int) msg->wParam > 0) ? GDK_SCROLL_UP : GDK_SCROLL_DOWN; event->scroll.window = window; - event->scroll.time = msg->time; + event->scroll.time = _gdk_win32_get_next_tick (msg->time); _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset); event->scroll.x = (gint16) pt.x + xoffset; event->scroll.y = (gint16) pt.y + yoffset; @@ -2452,7 +2416,7 @@ gdk_event_translate (GdkDisplay *display, event->key.type = ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN) ? GDK_KEY_PRESS : GDK_KEY_RELEASE); - event->key.time = msg->time; + event->key.time = _gdk_win32_get_next_tick (msg->time); event->key.state = 0; if (GetKeyState (VK_SHIFT) < 0) event->key.state |= GDK_SHIFT_MASK; @@ -2597,7 +2561,7 @@ gdk_event_translate (GdkDisplay *display, p_grab_automatic = TRUE; } - event->button.time = msg->time; + event->button.time = _gdk_win32_get_next_tick (msg->time); if (window != orig_window) translate_mouse_coords (orig_window, window, msg); event->button.x = current_x = (gint16) LOWORD (msg->lParam); @@ -2654,7 +2618,7 @@ gdk_event_translate (GdkDisplay *display, ASSIGN_WINDOW (window); event->button.window = window; - event->button.time = msg->time; + event->button.time = _gdk_win32_get_next_tick (msg->time); if (window != orig_window) translate_mouse_coords (orig_window, window, msg); _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset); @@ -2717,7 +2681,7 @@ gdk_event_translate (GdkDisplay *display, ASSIGN_WINDOW (window); event->motion.window = window; - event->motion.time = msg->time; + event->motion.time = _gdk_win32_get_next_tick (msg->time); if (window != orig_window) translate_mouse_coords (orig_window, window, msg); event->motion.x = current_x = (gint16) LOWORD (msg->lParam); @@ -2749,7 +2713,7 @@ gdk_event_translate (GdkDisplay *display, event->crossing.type = GDK_LEAVE_NOTIFY; event->crossing.window = current_window; event->crossing.subwindow = NULL; - event->crossing.time = msg->time; + event->crossing.time = _gdk_win32_get_next_tick (msg->time); _gdk_windowing_window_get_offsets (current_window, &xoffset, &yoffset); event->crossing.x = current_x + xoffset; event->crossing.y = current_y + yoffset; @@ -2817,7 +2781,7 @@ gdk_event_translate (GdkDisplay *display, event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ? GDK_SCROLL_UP : GDK_SCROLL_DOWN; event->scroll.window = window; - event->scroll.time = msg->time; + event->scroll.time = _gdk_win32_get_next_tick (msg->time); _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset); event->scroll.x = (gint16) pt.x + xoffset; event->scroll.y = (gint16) pt.y + yoffset; @@ -2839,7 +2803,7 @@ gdk_event_translate (GdkDisplay *display, event->crossing.type = GDK_LEAVE_NOTIFY; event->crossing.window = window; event->crossing.subwindow = NULL; - event->crossing.time = msg->time; + event->crossing.time = _gdk_win32_get_next_tick (msg->time); _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset); event->crossing.x = current_x + xoffset; event->crossing.y = current_y + yoffset; @@ -2919,8 +2883,8 @@ gdk_event_translate (GdkDisplay *display, break; case WM_ERASEBKGND: - GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %p dc %#x\n", - msg->hwnd, msg->wParam)); + GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %p dc %p\n", + msg->hwnd, (HANDLE) msg->wParam)); if (GDK_WINDOW_DESTROYED (window)) break; @@ -2928,27 +2892,24 @@ gdk_event_translate (GdkDisplay *display, erase_background (window, (HDC) msg->wParam); *ret_val_flagp = TRUE; /* always claim as handled */ *ret_valp = 1; - break; case WM_PAINT: - if (!GetUpdateRect (msg->hwnd, NULL, FALSE)) + hrgn = CreateRectRgn (0, 0, 0, 0); + if (GetUpdateRgn (msg->hwnd, hrgn, FALSE) == ERROR) { - GDK_NOTE (EVENTS, g_print ("WM_PAINT: %p no update rgn\n", - msg->hwnd)); + WIN32_GDI_FAILED ("GetUpdateRgn"); break; } hdc = BeginPaint (msg->hwnd, &paintstruct); - GDK_NOTE (EVENTS, - g_print ("WM_PAINT: %p %ldx%ld@+%ld+%ld %s dc %p\n", - msg->hwnd, - paintstruct.rcPaint.right - paintstruct.rcPaint.left, - paintstruct.rcPaint.bottom - paintstruct.rcPaint.top, - paintstruct.rcPaint.left, paintstruct.rcPaint.top, - (paintstruct.fErase ? "erase" : ""), - hdc)); + GDK_NOTE (EVENTS, g_print ("WM_PAINT: %p %s %s dc %p%s\n", + msg->hwnd, + _gdk_win32_rect_to_string (&paintstruct.rcPaint), + (paintstruct.fErase ? "erase" : ""), + hdc, + (return_exposes ? " return_exposes" : ""))); EndPaint (msg->hwnd, &paintstruct); @@ -2956,10 +2917,17 @@ gdk_event_translate (GdkDisplay *display, * windows -> backing store now works! */ if (GDK_WINDOW_OBJECT (window)->input_only) - break; + { + DeleteObject (hrgn); + break; + } if (!(private->event_mask & GDK_EXPOSURE_MASK)) - break; + { + GDK_NOTE (EVENTS, g_print ("...ignored\n")); + DeleteObject (hrgn); + break; + } #if 0 /* we need to process exposes even with GDK_NO_BG * Otherwise The GIMP canvas update is broken .... @@ -2970,19 +2938,14 @@ gdk_event_translate (GdkDisplay *display, if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left) || (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top)) - break; + { + GDK_NOTE (EVENTS, g_print ("...empty paintstruct, ignored\n")); + DeleteObject (hrgn); + break; + } if (return_exposes) { - hrgn = CreateRectRgn (0, 0, 0, 0); - if ((k = GetUpdateRgn (msg->hwnd, hrgn, FALSE)) == ERROR) - WIN32_GDI_FAILED ("GetUpdateRgn"); - else if (k == NULLREGION) - { - DeleteObject (hrgn); - break; - } - event->expose.type = GDK_EXPOSE; event->expose.window = window; event->expose.area.x = paintstruct.rcPaint.left; @@ -2992,37 +2955,34 @@ gdk_event_translate (GdkDisplay *display, event->expose.region = _gdk_win32_hrgn_to_region (hrgn); event->expose.count = 0; - DeleteObject (hrgn); - return_val = !GDK_WINDOW_DESTROYED (window); if (return_val) { GList *list = display->queued_events; while (list != NULL ) { - if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) && - (((GdkEvent *)list->data)->any.window == window) && - !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING)) - ((GdkEvent *)list->data)->expose.count++; + GdkEventPrivate *event = list->data; + if (event->event.any.type == GDK_EXPOSE && + event->event.any.window == window && + !(event->flags & GDK_EVENT_PENDING)) + event->event.expose.count++; - list = list->next; + list = list->next; } } } else { - GdkRectangle expose_rect; + GdkRegion *update_region = _gdk_win32_hrgn_to_region (hrgn); _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset); - expose_rect.x = paintstruct.rcPaint.left + xoffset; - expose_rect.y = paintstruct.rcPaint.top + yoffset; - expose_rect.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left; - expose_rect.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top; - - _gdk_window_process_expose (window, msg->time, &expose_rect); + gdk_region_offset (update_region, xoffset, yoffset); + _gdk_window_process_expose (window, update_region); + gdk_region_destroy (update_region); return_val = FALSE; } + DeleteObject (hrgn); break; case WM_GETICON: @@ -3312,7 +3272,7 @@ gdk_event_translate (GdkDisplay *display, } event->selection.property = _gdk_selection_property; event->selection.requestor = (guint32) msg->hwnd; - event->selection.time = msg->time; + event->selection.time = _gdk_win32_get_next_tick (msg->time); return_val = !GDK_WINDOW_DESTROYED (window); #else /* Test code, to see if SetClipboardData works when called from @@ -3352,7 +3312,7 @@ gdk_event_translate (GdkDisplay *display, return_val = window != NULL && !GDK_WINDOW_DESTROYED (window); - if ((window != NULL) && (gdk_root_window != msg->hwnd)) + if ((window != NULL) && (_gdk_root_window != msg->hwnd)) gdk_window_destroy_notify (window); break; @@ -3386,7 +3346,7 @@ gdk_event_translate (GdkDisplay *display, default: GDK_NOTE (EVENTS, g_print ("%s: %p %#x %#lx\n", - gdk_win32_message_name (msg->message), + _gdk_win32_message_to_string (msg->message), msg->hwnd, msg->wParam, msg->lParam)); } @@ -3451,7 +3411,7 @@ gdk_event_prepare (GSource *source, *timeout = -1; retval = (_gdk_event_queue_find_first (display) != NULL) - || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE); + || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE); GDK_THREADS_LEAVE (); @@ -3552,241 +3512,3 @@ gdk_display_sync (GdkDisplay * display) DispatchMessage (&msg); } } - -#ifdef G_ENABLE_DEBUG - -gchar * -gdk_win32_message_name (UINT msg) -{ - static gchar bfr[100]; - - switch (msg) - { -#define CASE(x) case x: return #x - CASE (WM_NULL); - CASE (WM_CREATE); - CASE (WM_DESTROY); - CASE (WM_MOVE); - CASE (WM_SIZE); - CASE (WM_ACTIVATE); - CASE (WM_SETFOCUS); - CASE (WM_KILLFOCUS); - CASE (WM_ENABLE); - CASE (WM_SETREDRAW); - CASE (WM_SETTEXT); - CASE (WM_GETTEXT); - CASE (WM_GETTEXTLENGTH); - CASE (WM_PAINT); - CASE (WM_CLOSE); - CASE (WM_QUERYENDSESSION); - CASE (WM_QUERYOPEN); - CASE (WM_ENDSESSION); - CASE (WM_QUIT); - CASE (WM_ERASEBKGND); - CASE (WM_SYSCOLORCHANGE); - CASE (WM_SHOWWINDOW); - CASE (WM_WININICHANGE); - CASE (WM_DEVMODECHANGE); - CASE (WM_ACTIVATEAPP); - CASE (WM_FONTCHANGE); - CASE (WM_TIMECHANGE); - CASE (WM_CANCELMODE); - CASE (WM_SETCURSOR); - CASE (WM_MOUSEACTIVATE); - CASE (WM_CHILDACTIVATE); - CASE (WM_QUEUESYNC); - CASE (WM_GETMINMAXINFO); - CASE (WM_PAINTICON); - CASE (WM_ICONERASEBKGND); - CASE (WM_NEXTDLGCTL); - CASE (WM_SPOOLERSTATUS); - CASE (WM_DRAWITEM); - CASE (WM_MEASUREITEM); - CASE (WM_DELETEITEM); - CASE (WM_VKEYTOITEM); - CASE (WM_CHARTOITEM); - CASE (WM_SETFONT); - CASE (WM_GETFONT); - CASE (WM_SETHOTKEY); - CASE (WM_GETHOTKEY); - CASE (WM_QUERYDRAGICON); - CASE (WM_COMPAREITEM); - CASE (WM_GETOBJECT); - CASE (WM_COMPACTING); - CASE (WM_WINDOWPOSCHANGING); - CASE (WM_WINDOWPOSCHANGED); - CASE (WM_POWER); - CASE (WM_COPYDATA); - CASE (WM_CANCELJOURNAL); - CASE (WM_NOTIFY); - CASE (WM_INPUTLANGCHANGEREQUEST); - CASE (WM_INPUTLANGCHANGE); - CASE (WM_TCARD); - CASE (WM_HELP); - CASE (WM_USERCHANGED); - CASE (WM_NOTIFYFORMAT); - CASE (WM_CONTEXTMENU); - CASE (WM_STYLECHANGING); - CASE (WM_STYLECHANGED); - CASE (WM_DISPLAYCHANGE); - CASE (WM_GETICON); - CASE (WM_SETICON); - CASE (WM_NCCREATE); - CASE (WM_NCDESTROY); - CASE (WM_NCCALCSIZE); - CASE (WM_NCHITTEST); - CASE (WM_NCPAINT); - CASE (WM_NCACTIVATE); - CASE (WM_GETDLGCODE); - CASE (WM_SYNCPAINT); - CASE (WM_NCMOUSEMOVE); - CASE (WM_NCLBUTTONDOWN); - CASE (WM_NCLBUTTONUP); - CASE (WM_NCLBUTTONDBLCLK); - CASE (WM_NCRBUTTONDOWN); - CASE (WM_NCRBUTTONUP); - CASE (WM_NCRBUTTONDBLCLK); - CASE (WM_NCMBUTTONDOWN); - CASE (WM_NCMBUTTONUP); - CASE (WM_NCMBUTTONDBLCLK); - CASE (WM_NCXBUTTONDOWN); - CASE (WM_NCXBUTTONUP); - CASE (WM_NCXBUTTONDBLCLK); - CASE (WM_KEYDOWN); - CASE (WM_KEYUP); - CASE (WM_CHAR); - CASE (WM_DEADCHAR); - CASE (WM_SYSKEYDOWN); - CASE (WM_SYSKEYUP); - CASE (WM_SYSCHAR); - CASE (WM_SYSDEADCHAR); - CASE (WM_KEYLAST); - CASE (WM_IME_STARTCOMPOSITION); - CASE (WM_IME_ENDCOMPOSITION); - CASE (WM_IME_COMPOSITION); - CASE (WM_INITDIALOG); - CASE (WM_COMMAND); - CASE (WM_SYSCOMMAND); - CASE (WM_TIMER); - CASE (WM_HSCROLL); - CASE (WM_VSCROLL); - CASE (WM_INITMENU); - CASE (WM_INITMENUPOPUP); - CASE (WM_MENUSELECT); - CASE (WM_MENUCHAR); - CASE (WM_ENTERIDLE); - CASE (WM_MENURBUTTONUP); - CASE (WM_MENUDRAG); - CASE (WM_MENUGETOBJECT); - CASE (WM_UNINITMENUPOPUP); - CASE (WM_MENUCOMMAND); - CASE (WM_CHANGEUISTATE); - CASE (WM_UPDATEUISTATE); - CASE (WM_QUERYUISTATE); - CASE (WM_CTLCOLORMSGBOX); - CASE (WM_CTLCOLOREDIT); - CASE (WM_CTLCOLORLISTBOX); - CASE (WM_CTLCOLORBTN); - CASE (WM_CTLCOLORDLG); - CASE (WM_CTLCOLORSCROLLBAR); - CASE (WM_CTLCOLORSTATIC); - CASE (WM_MOUSEMOVE); - CASE (WM_LBUTTONDOWN); - CASE (WM_LBUTTONUP); - CASE (WM_LBUTTONDBLCLK); - CASE (WM_RBUTTONDOWN); - CASE (WM_RBUTTONUP); - CASE (WM_RBUTTONDBLCLK); - CASE (WM_MBUTTONDOWN); - CASE (WM_MBUTTONUP); - CASE (WM_MBUTTONDBLCLK); - CASE (WM_MOUSEWHEEL); - CASE (WM_XBUTTONDOWN); - CASE (WM_XBUTTONUP); - CASE (WM_XBUTTONDBLCLK); - CASE (WM_PARENTNOTIFY); - CASE (WM_ENTERMENULOOP); - CASE (WM_EXITMENULOOP); - CASE (WM_NEXTMENU); - CASE (WM_SIZING); - CASE (WM_CAPTURECHANGED); - CASE (WM_MOVING); - CASE (WM_POWERBROADCAST); - CASE (WM_DEVICECHANGE); - CASE (WM_MDICREATE); - CASE (WM_MDIDESTROY); - CASE (WM_MDIACTIVATE); - CASE (WM_MDIRESTORE); - CASE (WM_MDINEXT); - CASE (WM_MDIMAXIMIZE); - CASE (WM_MDITILE); - CASE (WM_MDICASCADE); - CASE (WM_MDIICONARRANGE); - CASE (WM_MDIGETACTIVE); - CASE (WM_MDISETMENU); - CASE (WM_ENTERSIZEMOVE); - CASE (WM_EXITSIZEMOVE); - CASE (WM_DROPFILES); - CASE (WM_MDIREFRESHMENU); - CASE (WM_IME_SETCONTEXT); - CASE (WM_IME_NOTIFY); - CASE (WM_IME_CONTROL); - CASE (WM_IME_COMPOSITIONFULL); - CASE (WM_IME_SELECT); - CASE (WM_IME_CHAR); - CASE (WM_IME_REQUEST); - CASE (WM_IME_KEYDOWN); - CASE (WM_IME_KEYUP); - CASE (WM_MOUSEHOVER); - CASE (WM_MOUSELEAVE); - CASE (WM_NCMOUSEHOVER); - CASE (WM_NCMOUSELEAVE); - CASE (WM_CUT); - CASE (WM_COPY); - CASE (WM_PASTE); - CASE (WM_CLEAR); - CASE (WM_UNDO); - CASE (WM_RENDERFORMAT); - CASE (WM_RENDERALLFORMATS); - CASE (WM_DESTROYCLIPBOARD); - CASE (WM_DRAWCLIPBOARD); - CASE (WM_PAINTCLIPBOARD); - CASE (WM_VSCROLLCLIPBOARD); - CASE (WM_SIZECLIPBOARD); - CASE (WM_ASKCBFORMATNAME); - CASE (WM_CHANGECBCHAIN); - CASE (WM_HSCROLLCLIPBOARD); - CASE (WM_QUERYNEWPALETTE); - CASE (WM_PALETTEISCHANGING); - CASE (WM_PALETTECHANGED); - CASE (WM_HOTKEY); - CASE (WM_PRINT); - CASE (WM_PRINTCLIENT); - CASE (WM_APPCOMMAND); - CASE (WM_HANDHELDFIRST); - CASE (WM_HANDHELDLAST); - CASE (WM_AFXFIRST); - CASE (WM_AFXLAST); - CASE (WM_PENWINFIRST); - CASE (WM_PENWINLAST); - CASE (WM_APP); -#undef CASE - default: - if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST) - sprintf (bfr, "WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST); - else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST) - sprintf (bfr, "WM_AFXFIRST+%d", msg - WM_AFXFIRST); - else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST) - sprintf (bfr, "WM_PENWINFIRST+%d", msg - WM_PENWINFIRST); - else if (msg >= WM_USER && msg <= 0x7FFF) - sprintf (bfr, "WM_USER+%d", msg - WM_USER); - else if (msg >= 0xC000 && msg <= 0xFFFF) - sprintf (bfr, "reg-%#x", msg); - else - sprintf (bfr, "unk-%#x", msg); - return bfr; - } - g_assert_not_reached (); -} - -#endif /* G_ENABLE_DEBUG */ diff --git a/gdk/win32/gdkfont-win32.c b/gdk/win32/gdkfont-win32.c index 15eac58ec9..1e368628cc 100644 --- a/gdk/win32/gdkfont-win32.c +++ b/gdk/win32/gdkfont-win32.c @@ -893,11 +893,11 @@ gdk_font_load_logfont (LOGFONT *lfp) singlefont = g_new (GdkWin32SingleFont, 1); singlefont->hfont = hfont; GetObject (singlefont->hfont, sizeof (logfont), &logfont); - oldfont = SelectObject (gdk_display_hdc, singlefont->hfont); + oldfont = SelectObject (_gdk_display_hdc, singlefont->hfont); memset (&singlefont->fs, 0, sizeof (singlefont->fs)); - singlefont->charset = GetTextCharsetInfo (gdk_display_hdc, &singlefont->fs, 0); - GetTextFace (gdk_display_hdc, sizeof (face), face); - SelectObject (gdk_display_hdc, oldfont); + singlefont->charset = GetTextCharsetInfo (_gdk_display_hdc, &singlefont->fs, 0); + GetTextFace (_gdk_display_hdc, sizeof (face), face); + SelectObject (_gdk_display_hdc, oldfont); if (TranslateCharsetInfo ((DWORD *) singlefont->charset, &csi, TCI_SRCCHARSET) && singlefont->charset != MAC_CHARSET) @@ -905,8 +905,8 @@ gdk_font_load_logfont (LOGFONT *lfp) else singlefont->codepage = 0; - GDK_NOTE (MISC, (g_print ("... = %#x %s cs %s cp%d\n", - (guint) singlefont->hfont, face, + GDK_NOTE (MISC, (g_print ("... = %p %s cs %s cp%d\n", + singlefont->hfont, face, charset_name (singlefont->charset), singlefont->codepage), g_print ("... Unicode subranges:"), @@ -1011,7 +1011,7 @@ gdk_font_load_internal (const gchar *font_name) return NULL; } - logpixelsy = GetDeviceCaps (gdk_display_hdc, LOGPIXELSY); + logpixelsy = GetDeviceCaps (_gdk_display_hdc, LOGPIXELSY); if (strcmp (pixel_size, "*") == 0) if (strcmp (point_size, "*") == 0) @@ -1177,9 +1177,9 @@ gdk_font_from_one_singlefont (GdkWin32SingleFont *singlefont) * chars to work. (Yes, even Latin-1, as we use Unicode internally.) */ font->type = GDK_FONT_FONTSET; - oldfont = SelectObject (gdk_display_hdc, singlefont->hfont); - GetTextMetrics (gdk_display_hdc, &textmetric); - SelectObject (gdk_display_hdc, oldfont); + oldfont = SelectObject (_gdk_display_hdc, singlefont->hfont); + GetTextMetrics (_gdk_display_hdc, &textmetric); + SelectObject (_gdk_display_hdc, oldfont); font->ascent = textmetric.tmAscent; font->descent = textmetric.tmDescent; @@ -1220,9 +1220,9 @@ gdk_font_load_for_display (GdkDisplay *display, * chars to work. (Yes, even Latin-1, as we use Unicode internally.) */ font->type = GDK_FONT_FONTSET; - oldfont = SelectObject (gdk_display_hdc, singlefont->hfont); - GetTextMetrics (gdk_display_hdc, &textmetric); - SelectObject (gdk_display_hdc, oldfont); + oldfont = SelectObject (_gdk_display_hdc, singlefont->hfont); + GetTextMetrics (_gdk_display_hdc, &textmetric); + SelectObject (_gdk_display_hdc, oldfont); font->ascent = textmetric.tmAscent; font->descent = textmetric.tmDescent; @@ -1309,9 +1309,9 @@ gdk_fontset_load (const gchar *fontset_name) if (singlefont) { private->fonts = g_slist_append (private->fonts, singlefont); - oldfont = SelectObject (gdk_display_hdc, singlefont->hfont); - GetTextMetrics (gdk_display_hdc, &textmetric); - SelectObject (gdk_display_hdc, oldfont); + oldfont = SelectObject (_gdk_display_hdc, singlefont->hfont); + GetTextMetrics (_gdk_display_hdc, &textmetric); + SelectObject (_gdk_display_hdc, oldfont); font->ascent = MAX (font->ascent, textmetric.tmAscent); font->descent = MAX (font->descent, textmetric.tmDescent); } @@ -1342,8 +1342,8 @@ _gdk_font_destroy (GdkFont *font) GSList *list; singlefont = (GdkWin32SingleFont *) private->fonts->data; - GDK_NOTE (MISC, g_print ("_gdk_font_destroy %#x\n", - (guint)singlefont->hfont)); + GDK_NOTE (MISC, g_print ("_gdk_font_destroy %p\n", + singlefont->hfont)); gdk_font_hash_remove (font->type, font); @@ -1506,9 +1506,9 @@ _gdk_wchar_text_handle (GdkFont *font, if (!list) singlefont = NULL; - GDK_NOTE (MISC, g_print ("%d:%d:%d:%#x ", + GDK_NOTE (MISC, g_print ("%d:%d:%d:%p ", start-wcstr, wcp-wcstr, block, - (singlefont ? (guint) singlefont->hfont : 0))); + (singlefont ? singlefont->hfont : 0))); /* Call the callback function */ (*handler) (singlefont, start, wcp+1 - start, arg); @@ -1535,56 +1535,18 @@ gdk_text_size_handler (GdkWin32SingleFont *singlefont, if (!singlefont) return; - if ((oldfont = SelectObject (gdk_display_hdc, singlefont->hfont)) == NULL) + if ((oldfont = SelectObject (_gdk_display_hdc, singlefont->hfont)) == NULL) { WIN32_GDI_FAILED ("SelectObject"); return; } - GetTextExtentPoint32W (gdk_display_hdc, wcstr, wclen, &this_size); - SelectObject (gdk_display_hdc, oldfont); + GetTextExtentPoint32W (_gdk_display_hdc, wcstr, wclen, &this_size); + SelectObject (_gdk_display_hdc, oldfont); arg->total.cx += this_size.cx; arg->total.cy = MAX (arg->total.cy, this_size.cy); } -static gboolean -gdk_text_size (GdkFont *font, - const gchar *text, - gint text_length, - gdk_text_size_arg *arg) -{ - gint wlen; - wchar_t *wcstr; - - g_return_val_if_fail (font != NULL, FALSE); - g_return_val_if_fail (text != NULL, FALSE); - - if (text_length == 0) - return 0; - - g_assert (font->type == GDK_FONT_FONT || font->type == GDK_FONT_FONTSET); - - wcstr = g_new (wchar_t, text_length); - if (text_length == 1) - { - /* For single characters, don't try to interpret as UTF-8. - */ - wcstr[0] = (guchar) text[0]; - _gdk_wchar_text_handle (font, wcstr, 1, gdk_text_size_handler, arg); - } - else - { - if ((wlen = _gdk_utf8_to_ucs2 (wcstr, text, text_length, text_length)) == -1) - g_warning ("gdk_text_size: _gdk_utf8_to_ucs2 failed"); - else - _gdk_wchar_text_handle (font, wcstr, wlen, gdk_text_size_handler, arg); - } - - g_free (wcstr); - - return TRUE; -} - gint gdk_text_width (GdkFont *font, const gchar *text, @@ -1605,6 +1567,7 @@ gdk_text_width_wc (GdkFont *font, gint width = -1; gdk_text_extents_wc (font, text, text_length, NULL, NULL, &width, NULL, NULL); + return width; } diff --git a/gdk/win32/gdkgc-win32.c b/gdk/win32/gdkgc-win32.c index 374122c860..cbb833c332 100644 --- a/gdk/win32/gdkgc-win32.c +++ b/gdk/win32/gdkgc-win32.c @@ -96,8 +96,8 @@ gdk_gc_win32_finalize (GObject *object) { GdkGCWin32 *win32_gc = GDK_GC_WIN32 (object); - if (win32_gc->clip_region) - gdk_region_destroy (win32_gc->clip_region); + if (win32_gc->hcliprgn != NULL) + DeleteObject (win32_gc->hcliprgn); if (win32_gc->values_mask & GDK_GC_FONT) gdk_font_unref (win32_gc->font); @@ -278,22 +278,12 @@ gdk_win32_gc_values_to_win32values (GdkGCValues *values, if (mask & GDK_GC_CLIP_MASK) { - if (win32_gc->clip_region != NULL) - { - gdk_region_destroy (win32_gc->clip_region); - win32_gc->clip_region = NULL; - } - if (win32_gc->hcliprgn != NULL) - { - DeleteObject (win32_gc->hcliprgn); - win32_gc->hcliprgn = NULL; - } + DeleteObject (win32_gc->hcliprgn); if (values->clip_mask != NULL) { - win32_gc->hcliprgn = - _gdk_win32_bitmap_to_region (values->clip_mask); + win32_gc->hcliprgn = _gdk_win32_bitmap_to_hrgn (values->clip_mask); win32_gc->values_mask |= GDK_GC_CLIP_MASK; } else @@ -369,8 +359,6 @@ gdk_win32_gc_values_to_win32values (GdkGCValues *values, win32_gc->pen_num_dashes = 0; } win32_gc->pen_style &= ~(PS_STYLE_MASK); - GDK_NOTE (GC, (g_print ("%sps|=LINE_SOLID", s), - s = ",")); win32_gc->pen_style |= PS_SOLID; break; case GDK_LINE_ON_OFF_DASH: @@ -382,12 +370,12 @@ gdk_win32_gc_values_to_win32values (GdkGCValues *values, * line endings ? --hb */ win32_gc->pen_style &= ~(PS_STYLE_MASK); - GDK_NOTE (GC, (g_print ("%sps|=DASH", s), - s = ",")); - win32_gc->pen_style |= PS_DASH; + win32_gc->pen_style |= PS_DASH; } break; } + GDK_NOTE (GC, (g_print ("%sps|=PS_STYLE_%s", s, _gdk_win32_psstyle_to_string (win32_gc->pen_style)), + s = ",")); win32_gc->values_mask |= GDK_GC_LINE_STYLE; } @@ -398,21 +386,17 @@ gdk_win32_gc_values_to_win32values (GdkGCValues *values, { case GDK_CAP_NOT_LAST: /* ??? */ case GDK_CAP_BUTT: - GDK_NOTE (GC, (g_print ("%sps|=ENDCAP_FLAT", s), - s = ",")); win32_gc->pen_style |= PS_ENDCAP_FLAT; break; case GDK_CAP_ROUND: - GDK_NOTE (GC, (g_print ("%sps|=ENDCAP_ROUND", s), - s = ",")); win32_gc->pen_style |= PS_ENDCAP_ROUND; break; case GDK_CAP_PROJECTING: - GDK_NOTE (GC, (g_print ("%sps|=ENDCAP_SQUARE", s), - s = ",")); win32_gc->pen_style |= PS_ENDCAP_SQUARE; break; } + GDK_NOTE (GC, (g_print ("%sps|=PS_ENDCAP_%s", s, _gdk_win32_psendcap_to_string (win32_gc->pen_style)), + s = ",")); win32_gc->values_mask |= GDK_GC_CAP_STYLE; } @@ -422,21 +406,17 @@ gdk_win32_gc_values_to_win32values (GdkGCValues *values, switch (values->join_style) { case GDK_JOIN_MITER: - GDK_NOTE (GC, (g_print ("%sps|=JOIN_MITER", s), - s = ",")); win32_gc->pen_style |= PS_JOIN_MITER; break; case GDK_JOIN_ROUND: - GDK_NOTE (GC, (g_print ("%sps|=JOIN_ROUND", s), - s = ",")); win32_gc->pen_style |= PS_JOIN_ROUND; break; case GDK_JOIN_BEVEL: - GDK_NOTE (GC, (g_print ("%sps|=JOIN_BEVEL", s), - s = ",")); win32_gc->pen_style |= PS_JOIN_BEVEL; break; } + GDK_NOTE (GC, (g_print ("%sps|=PS_JOIN_%s", s, _gdk_win32_psjoin_to_string (win32_gc->pen_style)), + s = ",")); win32_gc->values_mask |= GDK_GC_JOIN_STYLE; } GDK_NOTE (GC, g_print ("}\n")); @@ -458,8 +438,6 @@ _gdk_win32_gc_new (GdkDrawable *drawable, gc = g_object_new (_gdk_gc_win32_get_type (), NULL); win32_gc = GDK_GC_WIN32 (gc); - win32_gc->hdc = NULL; - win32_gc->clip_region = NULL; win32_gc->hcliprgn = NULL; /* Use the same default values as X11 does, even if they don't make @@ -482,6 +460,7 @@ _gdk_win32_gc_new (GdkDrawable *drawable, GDK_NOTE (GC, g_print ("_gdk_win32_gc_new: ")); gdk_win32_gc_values_to_win32values (values, mask, win32_gc); + win32_gc->hdc = NULL; win32_gc->hwnd = NULL; GDK_NOTE (GC, g_print (" = %p\n", gc)); @@ -624,36 +603,34 @@ gdk_gc_set_clip_rectangle (GdkGC *gc, win32_gc = GDK_GC_WIN32 (gc); if (win32_gc->hcliprgn) - { - DeleteObject (win32_gc->hcliprgn); - win32_gc->hcliprgn = NULL; - } - - if (win32_gc->clip_region) - gdk_region_destroy (win32_gc->clip_region); + DeleteObject (win32_gc->hcliprgn); if (rectangle) { - GDK_NOTE (GC, - g_print ("gdk_gc_set_clip_rectangle: %dx%d@+%d+%d\n", - rectangle->width, rectangle->height, - rectangle->x, rectangle->y)); - win32_gc->clip_region = gdk_region_rectangle (rectangle); + GDK_NOTE (GC, g_print ("gdk_gc_set_clip_rectangle: %s\n", + _gdk_win32_gdkrectangle_to_string (rectangle))); + win32_gc->hcliprgn = CreateRectRgn (rectangle->x, rectangle->y, + rectangle->x + rectangle->width, + rectangle->y + rectangle->height); win32_gc->values_mask |= GDK_GC_CLIP_MASK; } else { GDK_NOTE (GC, g_print ("gdk_gc_set_clip_rectangle: NULL\n")); - win32_gc->clip_region = NULL; + win32_gc->hcliprgn = NULL; win32_gc->values_mask &= ~GDK_GC_CLIP_MASK; } - win32_gc->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_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); } void -gdk_gc_set_clip_region (GdkGC *gc, - GdkRegion *region) +gdk_gc_set_clip_region (GdkGC *gc, + GdkRegion *region) { GdkGCWin32 *win32_gc; @@ -661,30 +638,28 @@ gdk_gc_set_clip_region (GdkGC *gc, win32_gc = GDK_GC_WIN32 (gc); - if (win32_gc->clip_region) - gdk_region_destroy (win32_gc->clip_region); + if (win32_gc->hcliprgn) + DeleteObject (win32_gc->hcliprgn); if (region) { - GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: %dx%d+%d+%d\n", - region->extents.x2 - region->extents.x1, - region->extents.y2 - region->extents.y1, - region->extents.x1, region->extents.y1)); + GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: %s\n", + _gdk_win32_gdkregion_to_string (region))); - win32_gc->clip_region = gdk_region_copy (region); + win32_gc->hcliprgn = _gdk_win32_gdkregion_to_hrgn (region, 0, 0); win32_gc->values_mask |= GDK_GC_CLIP_MASK; } else { GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: NULL\n")); - win32_gc->clip_region = NULL; + win32_gc->hcliprgn = NULL; win32_gc->values_mask &= ~GDK_GC_CLIP_MASK; } gc->clip_x_origin = 0; gc->clip_y_origin = 0; - + win32_gc->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN); } @@ -701,24 +676,29 @@ gdk_gc_copy (GdkGC *dst_gc, dst_win32_gc = GDK_GC_WIN32 (dst_gc); src_win32_gc = GDK_GC_WIN32 (src_gc); - if (dst_win32_gc->font != NULL) - gdk_font_unref (dst_win32_gc->font); - if (dst_win32_gc->tile != NULL) - gdk_drawable_unref (dst_win32_gc->tile); - if (dst_win32_gc->stipple != NULL) - gdk_drawable_unref (dst_win32_gc->stipple); - if (dst_win32_gc->clip_region != NULL) - gdk_region_destroy (dst_win32_gc->clip_region); + if (dst_gc->colormap) + g_object_unref (G_OBJECT (dst_gc->colormap)); + if (dst_win32_gc->hcliprgn != NULL) DeleteObject (dst_win32_gc->hcliprgn); + + if (dst_win32_gc->font != NULL) + gdk_font_unref (dst_win32_gc->font); + + if (dst_win32_gc->tile != NULL) + gdk_drawable_unref (dst_win32_gc->tile); + + if (dst_win32_gc->stipple != NULL) + gdk_drawable_unref (dst_win32_gc->stipple); + if (dst_win32_gc->pen_dashes) g_free (dst_win32_gc->pen_dashes); *dst_win32_gc = *src_win32_gc; - if (dst_win32_gc->pen_dashes) - dst_win32_gc->pen_dashes = g_memdup (src_win32_gc->pen_dashes, - sizeof (DWORD) * src_win32_gc->pen_num_dashes); + if (dst_gc->colormap) + g_object_ref (G_OBJECT (dst_gc->colormap)); + if (dst_win32_gc->hcliprgn) { /* create a new region, to copy to */ @@ -727,14 +707,19 @@ gdk_gc_copy (GdkGC *dst_gc, CombineRgn (dst_win32_gc->hcliprgn, src_win32_gc->hcliprgn, NULL, RGN_COPY); } - if (dst_win32_gc->clip_region != NULL) - dst_win32_gc->clip_region = gdk_region_copy (dst_win32_gc->clip_region); + if (dst_win32_gc->font != NULL) gdk_font_ref (dst_win32_gc->font); + if (dst_win32_gc->tile != NULL) gdk_drawable_ref (dst_win32_gc->tile); + if (dst_win32_gc->stipple != NULL) gdk_drawable_ref (dst_win32_gc->stipple); + + if (dst_win32_gc->pen_dashes) + dst_win32_gc->pen_dashes = g_memdup (src_win32_gc->pen_dashes, + sizeof (DWORD) * src_win32_gc->pen_num_dashes); } static guint bitmask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 }; @@ -900,7 +885,6 @@ gdk_win32_hdc_get (GdkDrawable *drawable, GdkGCWin32 *win32_gc = (GdkGCWin32 *) gc; GdkDrawableImplWin32 *impl = NULL; gboolean ok = TRUE; - int flag; g_assert (win32_gc->hdc == NULL); @@ -954,164 +938,45 @@ gdk_win32_hdc_get (GdkDrawable *drawable, if (SetROP2 (win32_gc->hdc, win32_gc->rop2) == 0) WIN32_GDI_FAILED ("SetROP2"), ok = FALSE; - if (win32_gc->values_mask & GDK_GC_CLIP_MASK) - g_assert ((win32_gc->clip_region != NULL) != (win32_gc->hcliprgn != NULL)); - - if (ok - && (win32_gc->values_mask & GDK_GC_CLIP_MASK) - && win32_gc->clip_region != NULL) - { - HRGN hrgn; - RGNDATA *rgndata; - RECT *rect; - GdkRegionBox *boxes = win32_gc->clip_region->rects; - guint nbytes = - sizeof (RGNDATAHEADER) + (sizeof (RECT) * win32_gc->clip_region->numRects); - int i; - - rgndata = g_malloc (nbytes); - rgndata->rdh.dwSize = sizeof (RGNDATAHEADER); - rgndata->rdh.iType = RDH_RECTANGLES; - rgndata->rdh.nCount = rgndata->rdh.nRgnSize = 0; - SetRect (&rgndata->rdh.rcBound, - G_MAXSHORT, G_MAXSHORT, G_MINSHORT, G_MINSHORT); - - for (i = 0; i < win32_gc->clip_region->numRects; i++) - { - rect = ((RECT *) rgndata->Buffer) + rgndata->rdh.nCount++; - - rect->left = CLAMP (boxes[i].x1 + gc->clip_x_origin, - G_MINSHORT, G_MAXSHORT); - rect->right = CLAMP (boxes[i].x2 + gc->clip_x_origin, - G_MINSHORT, G_MAXSHORT); - rect->top = CLAMP (boxes[i].y1 + gc->clip_y_origin, - G_MINSHORT, G_MAXSHORT); - rect->bottom = CLAMP (boxes[i].y2 + gc->clip_y_origin, - G_MINSHORT, G_MAXSHORT); - - GDK_NOTE (GC, g_print ("clip rgn box %d: %ldx%ld@+%ld+%ld\n", - i, - rect->right-rect->left, - rect->bottom-rect->top, - rect->left, rect->top)); - - if (rect->left < rgndata->rdh.rcBound.left) - rgndata->rdh.rcBound.left = rect->left; - if (rect->right > rgndata->rdh.rcBound.right) - rgndata->rdh.rcBound.right = rect->right; - if (rect->top < rgndata->rdh.rcBound.top) - rgndata->rdh.rcBound.top = rect->top; - if (rect->bottom > rgndata->rdh.rcBound.bottom) - rgndata->rdh.rcBound.bottom = rect->bottom; - } - if ((hrgn = ExtCreateRegion (NULL, nbytes, rgndata)) == NULL) - WIN32_API_FAILED ("ExtCreateRegion"), ok = FALSE; - - g_free (rgndata); - - /* - * XXX: combine the fillmode-stipple with the clip region possibly - * this needs to be done with the hcliprgn below as well, but - * the test case here were check boxes and radio buttons ... - */ - if ( (win32_gc->values_mask & GDK_GC_STIPPLE) - && (win32_gc->values_mask & GDK_GC_FILL) && (win32_gc->fill_style == GDK_STIPPLED)) - { - HRGN hstipplergn = _gdk_win32_bitmap_to_region (win32_gc->stipple); - - if (OffsetRgn (hstipplergn, - win32_gc->values_mask & GDK_GC_TS_X_ORIGIN ? gc->ts_x_origin : 0, - win32_gc->values_mask & GDK_GC_TS_Y_ORIGIN ? gc->ts_y_origin : 0) == ERROR) - WIN32_API_FAILED ("OffsetRgn"), ok = FALSE; - if (CombineRgn (hrgn, hrgn, hstipplergn, RGN_AND) == ERROR) - WIN32_API_FAILED ("CombineRgn"), ok = FALSE; - if (!DeleteObject (hstipplergn)) - WIN32_API_FAILED ("DeleteObject"); - } - if (ok && SelectClipRgn (win32_gc->hdc, hrgn) == ERROR) - WIN32_API_FAILED ("SelectClipRgn"), ok = FALSE; - - if (hrgn != NULL) - DeleteObject (hrgn); - } - else if (ok - && (win32_gc->values_mask & GDK_GC_CLIP_MASK) - && win32_gc->hcliprgn != NULL) + if (ok && + (win32_gc->values_mask & GDK_GC_CLIP_MASK) && + win32_gc->hcliprgn != NULL) { if (SelectClipRgn (win32_gc->hdc, win32_gc->hcliprgn) == ERROR) WIN32_API_FAILED ("SelectClipRgn"), ok = FALSE; - if (ok && !OffsetClipRgn (win32_gc->hdc, - win32_gc->values_mask & GDK_GC_CLIP_X_ORIGIN ? gc->clip_x_origin : 0, - win32_gc->values_mask & GDK_GC_CLIP_Y_ORIGIN ? gc->clip_y_origin : 0)) + + /* Combine the fillmode-stipple with the clip region */ + if (ok && + (win32_gc->values_mask & GDK_GC_STIPPLE) && + (win32_gc->values_mask & GDK_GC_FILL) && + (win32_gc->fill_style == GDK_STIPPLED)) + { + HRGN hstipplergn; + + if ((hstipplergn = _gdk_win32_bitmap_to_hrgn (win32_gc->stipple)) == NULL) + ; + else if (win32_gc->values_mask & (GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN) && + OffsetRgn (hstipplergn, + win32_gc->values_mask & GDK_GC_TS_X_ORIGIN ? gc->ts_x_origin : 0, + win32_gc->values_mask & GDK_GC_TS_Y_ORIGIN ? gc->ts_y_origin : 0) == ERROR) + WIN32_API_FAILED ("OffsetRgn"); + else if (ExtSelectClipRgn (win32_gc->hdc, hstipplergn, RGN_AND) == ERROR) + WIN32_API_FAILED ("ExtSelectClipRgn"); + + if (hstipplergn != NULL && !DeleteObject (hstipplergn)) + WIN32_API_FAILED ("DeleteObject"); + } + + if (ok && win32_gc->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN) && + OffsetClipRgn (win32_gc->hdc, + win32_gc->values_mask & GDK_GC_CLIP_X_ORIGIN ? gc->clip_x_origin : 0, + win32_gc->values_mask & GDK_GC_CLIP_Y_ORIGIN ? gc->clip_y_origin : 0) == ERROR) WIN32_API_FAILED ("OffsetClipRgn"), ok = FALSE; } -#ifdef G_ENABLE_DEBUG - if (_gdk_debug_flags & GDK_DEBUG_GC) - { - HGDIOBJ obj; - LOGBRUSH logbrush; - EXTLOGPEN extlogpen; - HRGN hrgn; - RECT rect; - g_print ("gdk_win32_hdc_get: %p\n", win32_gc->hdc); - obj = GetCurrentObject (win32_gc->hdc, OBJ_BRUSH); - GetObject (obj, sizeof (LOGBRUSH), &logbrush); - g_print ("brush: style: %s color: %06lx hatch: %#lx\n", - (logbrush.lbStyle == BS_HOLLOW ? "HOLLOW" : - (logbrush.lbStyle == BS_PATTERN ? "PATTERN" : - (logbrush.lbStyle == BS_SOLID ? "SOLID" : - "???"))), - logbrush.lbColor, - logbrush.lbHatch); - obj = GetCurrentObject (win32_gc->hdc, OBJ_PEN); - GetObject (obj, sizeof (EXTLOGPEN), &extlogpen); - g_print ("pen: type: %s style: %s endcap: %s join: %s width: %d brush: %s\n", - ((extlogpen.elpPenStyle & PS_TYPE_MASK) == - PS_GEOMETRIC ? "GEOMETRIC" : "COSMETIC"), - ((extlogpen.elpPenStyle & PS_STYLE_MASK) == - PS_NULL ? "NULL" : - ((extlogpen.elpPenStyle & PS_STYLE_MASK) == PS_SOLID ? "SOLID" : - ((extlogpen.elpPenStyle & PS_STYLE_MASK) == PS_DOT ? "DOT" : - ((extlogpen.elpPenStyle & PS_STYLE_MASK) == PS_DASH ? "DASH" : - "???")))), - ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) == - PS_ENDCAP_FLAT ? "FLAT" : - ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) == - PS_ENDCAP_ROUND ? "ROUND" : - ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) == - PS_ENDCAP_SQUARE ? "ROUND" : - ((extlogpen.elpPenStyle & PS_ENDCAP_MASK) == - PS_ENDCAP_SQUARE ? "ROUND" : "???")))), - ((extlogpen.elpPenStyle & PS_JOIN_MASK) == - PS_JOIN_BEVEL ? "BEVEL" : - ((extlogpen.elpPenStyle & PS_JOIN_MASK) == - PS_JOIN_MITER ? "MITER" : - ((extlogpen.elpPenStyle & PS_JOIN_MASK) == - PS_JOIN_ROUND ? "ROUND" : "???"))), - extlogpen.elpWidth, - (extlogpen.elpBrushStyle == BS_DIBPATTERN ? "DIBPATTERN" : - (extlogpen.elpBrushStyle == BS_DIBPATTERNPT ? "DIBPATTERNPT" : - (extlogpen.elpBrushStyle == BS_HATCHED ? "HATCHED" : - (extlogpen.elpBrushStyle == BS_HOLLOW ? "HOLLOW" : - (extlogpen.elpBrushStyle == BS_PATTERN ? "PATTERN" : - (extlogpen.elpBrushStyle == BS_SOLID ? "SOLID" : "???"))))))); - hrgn = CreateRectRgn (0, 0, 0, 0); - if ((flag = GetClipRgn (win32_gc->hdc, hrgn)) == -1) - WIN32_API_FAILED ("GetClipRgn"); - else if (flag == 0) - g_print ("no clip region\n"); - else if (flag == 1) - { - GetRgnBox (hrgn, &rect); - g_print ("clip region bbox: %ldx%ld@+%ld+%ld\n", - rect.right - rect.left, - rect.bottom - rect.top, - rect.left, rect.top); - } - DeleteObject (hrgn); - } -#endif + GDK_NOTE (GC, (g_print ("gdk_win32_hdc_get: "), + _gdk_win32_print_dc (win32_gc->hdc))); + return win32_gc->hdc; } @@ -1191,12 +1056,12 @@ gdk_win32_hdc_release (GdkDrawable *drawable, * bitmaps (and not pixmaps), with zero pixels being transparent. */ -/* _gdk_win32_bitmap_to_region : Create a region from the +/* _gdk_win32_bitmap_to_hrgn : Create a region from the * "non-transparent" pixels of a bitmap. */ HRGN -_gdk_win32_bitmap_to_region (GdkPixmap *pixmap) +_gdk_win32_bitmap_to_hrgn (GdkPixmap *pixmap) { HRGN hRgn = NULL; HRGN h; @@ -1302,100 +1167,52 @@ _gdk_win32_bitmap_to_region (GdkPixmap *pixmap) return hRgn; } -#ifdef G_ENABLE_DEBUG - -gchar * -gdk_win32_cap_style_to_string (GdkCapStyle cap_style) +HRGN +_gdk_win32_gdkregion_to_hrgn (GdkRegion *region, + gint x_origin, + gint y_origin) { - switch (cap_style) - { -#define CASE(x) case x: return #x + strlen ("GDK_CAP_") - CASE (GDK_CAP_NOT_LAST); - CASE (GDK_CAP_BUTT); - CASE (GDK_CAP_ROUND); - CASE (GDK_CAP_PROJECTING); -#undef CASE - default: return ("illegal GdkCapStyle value"); - } - /* NOTREACHED */ - return NULL; -} + HRGN hrgn; + RGNDATA *rgndata; + RECT *rect; + GdkRegionBox *boxes = region->rects; + guint nbytes = + sizeof (RGNDATAHEADER) + (sizeof (RECT) * region->numRects); + int i; -gchar * -gdk_win32_fill_style_to_string (GdkFill fill) -{ - switch (fill) - { -#define CASE(x) case x: return #x + strlen ("GDK_") - CASE (GDK_SOLID); - CASE (GDK_TILED); - CASE (GDK_STIPPLED); - CASE (GDK_OPAQUE_STIPPLED); -#undef CASE - default: return ("illegal GdkFill value"); - } - /* NOTREACHED */ - return NULL; -} + rgndata = g_malloc (nbytes); + rgndata->rdh.dwSize = sizeof (RGNDATAHEADER); + rgndata->rdh.iType = RDH_RECTANGLES; + rgndata->rdh.nCount = rgndata->rdh.nRgnSize = 0; + SetRect (&rgndata->rdh.rcBound, + G_MAXSHORT, G_MAXSHORT, G_MINSHORT, G_MINSHORT); -gchar * -gdk_win32_function_to_string (GdkFunction function) -{ - switch (function) + for (i = 0; i < region->numRects; i++) { -#define CASE(x) case x: return #x + strlen ("GDK_") - CASE (GDK_COPY); - CASE (GDK_INVERT); - CASE (GDK_XOR); - CASE (GDK_CLEAR); - CASE (GDK_AND); - CASE (GDK_AND_REVERSE); - CASE (GDK_AND_INVERT); - CASE (GDK_NOOP); - CASE (GDK_OR); - CASE (GDK_EQUIV); - CASE (GDK_OR_REVERSE); - CASE (GDK_COPY_INVERT); - CASE (GDK_OR_INVERT); - CASE (GDK_NAND); - CASE (GDK_SET); -#undef CASE - default: return ("illegal GdkFunction value"); - } - /* NOTREACHED */ - return NULL; -} + rect = ((RECT *) rgndata->Buffer) + rgndata->rdh.nCount++; -gchar * -gdk_win32_join_style_to_string (GdkJoinStyle join_style) -{ - switch (join_style) - { -#define CASE(x) case x: return #x + strlen ("GDK_JOIN_") - CASE (GDK_JOIN_MITER); - CASE (GDK_JOIN_ROUND); - CASE (GDK_JOIN_BEVEL); -#undef CASE - default: return ("illegal GdkJoinStyle value"); - } - /* NOTREACHED */ - return NULL; -} + rect->left = CLAMP (boxes[i].x1 + x_origin, + G_MINSHORT, G_MAXSHORT); + rect->right = CLAMP (boxes[i].x2 + x_origin, + G_MINSHORT, G_MAXSHORT); + rect->top = CLAMP (boxes[i].y1 + y_origin, + G_MINSHORT, G_MAXSHORT); + rect->bottom = CLAMP (boxes[i].y2 + y_origin, + G_MINSHORT, G_MAXSHORT); -gchar * -gdk_win32_line_style_to_string (GdkLineStyle line_style) -{ - switch (line_style) - { -#define CASE(x) case x: return #x + strlen ("GDK_LINE_") - CASE(GDK_LINE_SOLID); - CASE(GDK_LINE_ON_OFF_DASH); - CASE(GDK_LINE_DOUBLE_DASH); -#undef CASE - default: return ("illegal GdkLineStyle value"); + if (rect->left < rgndata->rdh.rcBound.left) + rgndata->rdh.rcBound.left = rect->left; + if (rect->right > rgndata->rdh.rcBound.right) + rgndata->rdh.rcBound.right = rect->right; + if (rect->top < rgndata->rdh.rcBound.top) + rgndata->rdh.rcBound.top = rect->top; + if (rect->bottom > rgndata->rdh.rcBound.bottom) + rgndata->rdh.rcBound.bottom = rect->bottom; } - /* NOTREACHED */ - return NULL; -} + if ((hrgn = ExtCreateRegion (NULL, nbytes, rgndata)) == NULL) + WIN32_API_FAILED ("ExtCreateRegion"); -#endif + g_free (rgndata); + + return (hrgn); +} diff --git a/gdk/win32/gdkgeometry-win32.c b/gdk/win32/gdkgeometry-win32.c index 19725487c5..256a820aa9 100644 --- a/gdk/win32/gdkgeometry-win32.c +++ b/gdk/win32/gdkgeometry-win32.c @@ -39,6 +39,8 @@ typedef struct _GdkWindowQueueItem GdkWindowQueueItem; typedef struct _GdkWindowParentPos GdkWindowParentPos; +#if 0 + typedef enum { GDK_WINDOW_QUEUE_TRANSLATE, GDK_WINDOW_QUEUE_ANTIEXPOSE @@ -60,6 +62,8 @@ struct _GdkWindowQueueItem } u; }; +#endif + struct _GdkWindowParentPos { gint x; @@ -69,11 +73,12 @@ struct _GdkWindowParentPos GdkRectangle clip_rect; }; -static void gdk_window_compute_position (GdkWindowImplWin32 *window, +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_compute_parent_pos (GdkWindowImplWin32 *window, + GdkWindowParentPos *parent_pos); + static void gdk_window_premove (GdkWindow *window, GdkWindowParentPos *parent_pos); static void gdk_window_postmove (GdkWindow *window, @@ -87,7 +92,9 @@ static void gdk_window_clip_changed (GdkWindow *window, GdkRectangle *old_clip, GdkRectangle *new_clip); +#if 0 static GSList *translate_queue = NULL; +#endif void _gdk_windowing_window_get_offsets (GdkWindow *window, @@ -121,35 +128,55 @@ gdk_window_copy_area_scroll (GdkWindow *window, gint dx, gint dy) { +#if 0 GdkWindowObject *obj = GDK_WINDOW_OBJECT (window); GList *tmp_list; +#endif - GDK_NOTE (MISC, g_print ("gdk_window_copy_area_scroll: %p %dx%d@+%d+%d %d,%d\n", + GDK_NOTE (MISC, g_print ("gdk_window_copy_area_scroll: %p %s %d,%d\n", GDK_WINDOW_HWND (window), - dest_rect->width, dest_rect->height, - dest_rect->x, dest_rect->y, + _gdk_win32_gdkrectangle_to_string (dest_rect), dx, dy)); if (dest_rect->width > 0 && dest_rect->height > 0) { RECT clipRect; +#ifdef G_ENABLE_DEBUG + RECT update_rect; +#endif + clipRect.left = dest_rect->x; clipRect.top = dest_rect->y; clipRect.right = clipRect.left + dest_rect->width; clipRect.bottom = clipRect.top + dest_rect->height; + if (dx < 0) + clipRect.right -= dx; + else + clipRect.left -= dx; + if (dy < 0) + clipRect.bottom -= dy; + else + clipRect.top -= dy; + gdk_window_queue_translation (window, dx, dy); if (!ScrollWindowEx (GDK_WINDOW_HWND (window), dx, dy, /* in: scroll offsets */ NULL, /* in: scroll rect, NULL == entire client area */ &clipRect, /* in: restrict to */ - NULL, /* out: update region */ + NULL, /* in: update region */ NULL, /* out: update rect */ - SW_INVALIDATE)) + SW_INVALIDATE | SW_SCROLLCHILDREN)) WIN32_API_FAILED ("ScrollWindowEx"); + + GDK_NOTE (EVENTS, + (GetUpdateRect (GDK_WINDOW_HWND (window), &update_rect, FALSE), + g_print ("gdk_window_copy_area_scroll: post-scroll update rect: %s\n", + _gdk_win32_rect_to_string (&update_rect)))); } +#if 0 /* Not needed, ScrollWindowEx also scrolls the children. */ tmp_list = obj->children; while (tmp_list) { @@ -160,6 +187,7 @@ gdk_window_copy_area_scroll (GdkWindow *window, tmp_list = tmp_list->next; } +#endif } static void @@ -208,6 +236,8 @@ compute_intermediate_position (GdkWin32PositionInfo *position_info, new_position->height = new_y1 - new_y0; } +#if 0 + static void gdk_window_guffaw_scroll (GdkWindow *window, gint dx, @@ -223,7 +253,7 @@ gdk_window_guffaw_scroll (GdkWindow *window, GdkWindowParentPos parent_pos; GList *tmp_list; - GDK_NOTE (EVENTS, g_print ("gdk_window_guffaw_scroll %p %d,%d\n", + GDK_NOTE (EVENTS, g_print ("gdk_window_guffaw_scroll: %p %d,%d\n", GDK_WINDOW_HWND (window), dx, dy)); gdk_window_compute_parent_pos (impl, &parent_pos); @@ -250,7 +280,7 @@ gdk_window_guffaw_scroll (GdkWindow *window, */ if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL, new_position.x, new_position.y, - new_position.width, new_position.height, + new_position.width, new_position.height, SWP_NOACTIVATE | SWP_NOZORDER)) WIN32_API_FAILED ("SetWindowPos"); @@ -291,12 +321,16 @@ gdk_window_guffaw_scroll (GdkWindow *window, } } +#endif + void gdk_window_scroll (GdkWindow *window, gint dx, gint dy) { +#if 0 gboolean can_guffaw_scroll = FALSE; +#endif GdkRegion *invalidate_region; GdkWindowImplWin32 *impl; GdkWindowObject *obj; @@ -307,7 +341,7 @@ gdk_window_scroll (GdkWindow *window, if (GDK_WINDOW_DESTROYED (window)) return; - GDK_NOTE (EVENTS, g_print ("gdk_window_scroll %p %d,%d\n", + GDK_NOTE (EVENTS, g_print ("gdk_window_scroll: %p %d,%d\n", GDK_WINDOW_HWND (window), dx, dy)); obj = GDK_WINDOW_OBJECT (window); @@ -338,7 +372,7 @@ gdk_window_scroll (GdkWindow *window, gdk_window_invalidate_region (window, invalidate_region, TRUE); gdk_region_destroy (invalidate_region); - +#if 0 /* We can guffaw scroll if we are a child window, and the parent * does not extend beyond our edges. Otherwise, we use XCopyArea, then * move any children later @@ -354,6 +388,9 @@ gdk_window_scroll (GdkWindow *window, gdk_window_copy_area_scroll (window, &dest_rect, dx, dy); else gdk_window_guffaw_scroll (window, dx, dy); +#else + gdk_window_copy_area_scroll (window, &dest_rect, dx, dy); +#endif } void @@ -376,23 +413,28 @@ _gdk_window_move_resize_child (GdkWindow *window, g_return_if_fail (window != NULL); g_return_if_fail (GDK_IS_WINDOW (window)); - GDK_NOTE (MISC, g_print ("_gdk_window_move_resize_child: %p %dx%d@+%d+%d\n", - GDK_WINDOW_HWND (window), width, height, x, y)); - obj = GDK_WINDOW_OBJECT (window); impl = GDK_WINDOW_IMPL_WIN32 (obj->impl); + 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)); + dx = x - obj->x; dy = y - obj->y; is_move = dx != 0 || dy != 0; is_resize = impl->width != width || impl->height != height; - GDK_NOTE (MISC, g_print ("...is_move:%d is_resize:%d\n", is_move, is_resize)); - if (!is_move && !is_resize) - return; + { + GDK_NOTE (MISC, g_print ("...neither move or resize\n")); + return; + } + GDK_NOTE (MISC, g_print ("...%s%s\n", is_move ? "is_move " : "", is_resize ? "is_resize" : "")); + obj->x = x; obj->y = y; impl->width = width; @@ -426,10 +468,9 @@ _gdk_window_move_resize_child (GdkWindow *window, compute_intermediate_position (&impl->position_info, &new_info, d_xoffset, d_yoffset, &new_position); - GDK_NOTE (MISC, g_print ("...SetWindowPos(%p,%dx%d@+%d+%d)\n", + GDK_NOTE (MISC, g_print ("...SetWindowPos(%p,%s)\n", GDK_WINDOW_HWND (window), - new_position.width, new_position.height, - new_position.x, new_position.y)); + _gdk_win32_gdkrectangle_to_string (&new_position))); if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL, new_position.x, new_position.y, new_position.width, new_position.height, @@ -510,6 +551,7 @@ _gdk_window_move_resize_child (GdkWindow *window, 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))) WIN32_API_FAILED ("SetWindowPos"); @@ -561,9 +603,9 @@ gdk_window_compute_position (GdkWindowImplWin32 *window, 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 - SIZE_LIMIT - parent_pos->win32_x; + info->x = parent_pos->x + wrapper->x + window->width - info->width - parent_pos->win32_x; else - info->x = -(SIZE_LIMIT/2) - parent_pos->win32_y; + info->x = -(SIZE_LIMIT/2) - parent_pos->win32_x; } else info->x = parent_pos->x + wrapper->x - parent_pos->win32_x; @@ -581,7 +623,7 @@ gdk_window_compute_position (GdkWindowImplWin32 *window, 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 - SIZE_LIMIT - parent_pos->win32_y; + 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; } @@ -732,6 +774,12 @@ gdk_window_premove (GdkWindow *window, compute_intermediate_position (&impl->position_info, &new_info, d_xoffset, d_yoffset, &new_position); + GDK_NOTE (MISC, g_print ("gdk_window_premove: %s@+%d+%d\n" + "...SetWindowPos(%s)\n", + _gdk_win32_drawable_description (window), + obj->x, obj->y, + _gdk_win32_gdkrectangle_to_string (&new_position))); + if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL, new_position.x, new_position.y, new_position.width, new_position.height, @@ -777,6 +825,13 @@ gdk_window_postmove (GdkWindow *window, if (d_xoffset > 0 || d_yoffset > 0) gdk_window_queue_translation (window, MAX (d_xoffset, 0), MAX (d_yoffset, 0)); + GDK_NOTE (MISC, g_print ("gdk_window_postmove: %s@+%d+%d\n" + "...SetWindowPos(%dx%d@+%d+%d)\n", + _gdk_win32_drawable_description (window), + obj->x, obj->y, + new_info.width, new_info.height, + new_info.x, new_info.y)); + if (!SetWindowPos (GDK_WINDOW_HWND (window), NULL, new_info.x, new_info.y, new_info.width, new_info.height, @@ -800,6 +855,8 @@ gdk_window_postmove (GdkWindow *window, } } +#if 0 + static void gdk_window_queue_append (GdkWindow *window, GdkWindowQueueItem *item) @@ -809,93 +866,77 @@ gdk_window_queue_append (GdkWindow *window, GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl); GDK_NOTE (EVENTS, g_print ("gdk_window_queue_append: length >= 128\n")); - _gdk_window_process_expose (window, GetCurrentTime (), &impl->position_info.clip_rect); + _gdk_window_process_expose (window, _gdk_win32_get_next_tick (0), + &impl->position_info.clip_rect); } + item->window = window; + item->serial = GetTickCount (); + + GDK_NOTE (EVENTS, (g_print ("gdk_window_queue_append: %s %p %ld ", + (item->type == GDK_WINDOW_QUEUE_TRANSLATE ? + "TRANSLATE" : "ANTIEXPOSE"), + GDK_WINDOW_HWND (window), + item->serial), + (item->type == GDK_WINDOW_QUEUE_TRANSLATE ? + g_print ("%d,%d\n", + item->u.translate.dx, item->u.translate.dy) : + g_print ("%s\n", + _gdk_win32_gdkregion_to_string (item->u.antiexpose.area))))); + + gdk_drawable_ref (window); translate_queue = g_slist_append (translate_queue, item) ; } +#endif + static void gdk_window_queue_translation (GdkWindow *window, gint dx, gint dy) { +#if 0 GdkWindowQueueItem *item = g_new (GdkWindowQueueItem, 1); - item->window = window; - item->serial = GetMessageTime (); item->type = GDK_WINDOW_QUEUE_TRANSLATE; item->u.translate.dx = dx; item->u.translate.dy = dy; - GDK_NOTE (EVENTS, g_print ("gdk_window_queue_translation %p %ld %d,%d\n", - GDK_WINDOW_HWND (window), - item->serial, - dx, dy)); - - gdk_drawable_ref (window); gdk_window_queue_append (window, item); +#endif } gboolean _gdk_windowing_window_queue_antiexpose (GdkWindow *window, GdkRegion *area) { -#if 1 - GdkWindowQueueItem *item = g_new (GdkWindowQueueItem, 1); + HRGN hrgn = _gdk_win32_gdkregion_to_hrgn (area, 0, 0); - item->window = window; - item->serial = GetMessageTime (); - item->type = GDK_WINDOW_QUEUE_ANTIEXPOSE; - item->u.antiexpose.area = area; - - GDK_NOTE (EVENTS, g_print ("_gdk_windowing_window_queue_antiexpose %p %ld %dx%d@+%d+%d\n", + GDK_NOTE (EVENTS, g_print ("_gdk_windowing_window_queue_antiexpose: ValidateRgn %p %s\n", GDK_WINDOW_HWND (window), - item->serial, - area->extents.x2 - area->extents.x1, - area->extents.y2 - area->extents.y1, - area->extents.x1, area->extents.y1)); + _gdk_win32_gdkregion_to_string (area))); - gdk_drawable_ref (window); - gdk_window_queue_append (window, item); + ValidateRgn (GDK_WINDOW_HWND (window), hrgn); - return TRUE; -#else - GdkRectangle r; - HRGN hrgn; + DeleteObject (hrgn); - gdk_region_get_clipbox (area, &r); - hrgn = CreateRectRgn(r.x, r.y, r.width+1, r.height+1); - - g_return_val_if_fail (area != NULL, FALSE); - - GDK_NOTE (MISC, g_print ("_gdk_windowing_window_queue_antiexpose %p\n", - GDK_WINDOW_HWND (window))); - - /* HB: not quite sure if this is the right thing to do. - * (Region not to be proceesed by next WM_PAINT) - */ - ValidateRgn(GDK_WINDOW_HWND (window), hrgn); - DeleteObject(hrgn); - return TRUE; -#endif + return FALSE; } void _gdk_window_process_expose (GdkWindow *window, - gulong serial, - GdkRectangle *area) + GdkRegion *invalidate_region) { GdkWindowImplWin32 *impl; - GdkRegion *invalidate_region = gdk_region_rectangle (area); GdkRegion *clip_region; +#if 0 GSList *tmp_list = translate_queue; - +#endif impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl); - GDK_NOTE (EVENTS, g_print ("_gdk_window_process_expose %p %ld %dx%d@+%d+%d\n", - GDK_WINDOW_HWND (window), serial, - area->width, area->height, area->x, area->y)); - + GDK_NOTE (EVENTS, g_print ("_gdk_window_process_expose: %p %s\n", + GDK_WINDOW_HWND (window), + _gdk_win32_gdkregion_to_string (invalidate_region))); +#if 0 while (tmp_list) { GdkWindowQueueItem *item = tmp_list->data; @@ -906,15 +947,33 @@ _gdk_window_process_expose (GdkWindow *window, if (item->window == window) { if (item->type == GDK_WINDOW_QUEUE_TRANSLATE) - gdk_region_offset (invalidate_region, - item->u.translate.dx, - item->u.translate.dy); + { + GDK_NOTE (EVENTS, g_print ("...item %ld xlating region by %d,%d\n", + item->serial, + item->u.translate.dx, item->u.translate.dy)); + gdk_region_offset (invalidate_region, - item->u.translate.dx, - item->u.translate.dy); + } else /* anti-expose */ - gdk_region_subtract (invalidate_region, item->u.antiexpose.area); + { +#ifdef G_ENABLE_DEBUG + GdkRectangle rect; + + GDK_NOTE (EVENTS, + (gdk_region_get_clipbox (item->u.antiexpose.area, &rect), + g_print ("...item %ld antiexposing %s\n", + item->serial, + _gdk_win32_gdkrectangle_to_string (&rect)))); +#endif + gdk_region_subtract (invalidate_region, item->u.antiexpose.area); + } } } else { GSList *tmp_link = translate_queue; + GDK_NOTE (EVENTS, g_print ("...item %ld being removed\n", item->serial)); + translate_queue = g_slist_remove_link (translate_queue, translate_queue); gdk_drawable_unref (item->window); @@ -926,13 +985,14 @@ _gdk_window_process_expose (GdkWindow *window, } } + GDK_NOTE (EVENTS, g_print ("...queue length now %d\n", g_slist_length (translate_queue))); +#endif 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_region_destroy (invalidate_region); gdk_region_destroy (clip_region); } @@ -980,7 +1040,9 @@ gdk_window_tmp_reset_bg (GdkWindow *window) } static void -gdk_window_clip_changed (GdkWindow *window, GdkRectangle *old_clip, GdkRectangle *new_clip) +gdk_window_clip_changed (GdkWindow *window, + GdkRectangle *old_clip, + GdkRectangle *new_clip) { GdkWindowImplWin32 *impl; GdkWindowObject *obj; @@ -1012,6 +1074,9 @@ gdk_window_clip_changed (GdkWindow *window, GdkRectangle *old_clip, GdkRectangle if (!gdk_region_empty (new_clip_region)) { gdk_window_tmp_unset_bg (window); + GDK_NOTE (EVENTS, + g_print ("gdk_window_clip_changed: invalidating region: %s\n", + _gdk_win32_gdkregion_to_string (new_clip_region))); gdk_window_invalidate_region (window, new_clip_region, FALSE); } diff --git a/gdk/win32/gdkglobals-win32.c b/gdk/win32/gdkglobals-win32.c index b72f7cea51..3b28b9895a 100644 --- a/gdk/win32/gdkglobals-win32.c +++ b/gdk/win32/gdkglobals-win32.c @@ -28,29 +28,29 @@ #include "gdktypes.h" #include "gdkprivate-win32.h" -HWND gdk_root_window = NULL; -HDC gdk_display_hdc; -HINSTANCE gdk_dll_hinstance; -HINSTANCE gdk_app_hmodule; +HWND _gdk_root_window = NULL; +HDC _gdk_display_hdc; +HINSTANCE _gdk_dll_hinstance; +HINSTANCE _gdk_app_hmodule; HKL _gdk_input_locale; UINT _gdk_input_codepage; -WORD cf_rtf; -WORD cf_utf8_string; +WORD _cf_rtf; +WORD _cf_utf8_string; -GdkAtom utf8_string; -GdkAtom compound_text; -GdkAtom text_uri_list; +GdkAtom _utf8_string; +GdkAtom _compound_text; +GdkAtom _text_uri_list; -GdkAtom local_dnd; -GdkAtom gdk_win32_dropfiles; -GdkAtom gdk_ole2_dnd; +GdkAtom _local_dnd; +GdkAtom _gdk_win32_dropfiles; +GdkAtom _gdk_ole2_dnd; GdkAtom _gdk_selection_property; -DWORD windows_version; +DWORD _windows_version; -gint gdk_input_ignore_wintab = FALSE; -gint gdk_event_func_from_window_proc = FALSE; -gint gdk_max_colors = 0; +gint _gdk_input_ignore_wintab = FALSE; +gint _gdk_event_func_from_window_proc = FALSE; +gint _gdk_max_colors = 0; diff --git a/gdk/win32/gdkinput-win32.c b/gdk/win32/gdkinput-win32.c index 5d1e60d971..4989dcde6a 100644 --- a/gdk/win32/gdkinput-win32.c +++ b/gdk/win32/gdkinput-win32.c @@ -213,7 +213,7 @@ gdk_input_wintab_init (void) _gdk_input_devices = NULL; wintab_contexts = NULL; - if (!gdk_input_ignore_wintab && + if (!_gdk_input_ignore_wintab && WTInfo (0, 0, NULL)) { WTInfo (WTI_INTERFACE, IFC_SPECVERSION, &specversion); @@ -848,7 +848,7 @@ _gdk_input_other_event (GdkEvent *event, if (event->any.type == GDK_BUTTON_PRESS || event->any.type == GDK_BUTTON_RELEASE) { - event->button.time = msg->time; + event->button.time = _gdk_win32_get_next_tick (msg->time); event->button.device = &gdkdev->info; #if 0 @@ -877,7 +877,7 @@ _gdk_input_other_event (GdkEvent *event, } else { - event->motion.time = msg->time; + event->motion.time = _gdk_win32_get_next_tick (msg->time); event->motion.is_hint = FALSE; event->motion.device = &gdkdev->info; @@ -946,7 +946,7 @@ _gdk_input_other_event (GdkEvent *event, event->proximity.type = GDK_PROXIMITY_IN; _gdk_input_ignore_core = TRUE; } - event->proximity.time = msg->time; + event->proximity.time = _gdk_win32_get_next_tick (msg->time); event->proximity.device = &gdkdev->info; GDK_NOTE (EVENTS_OR_INPUT, diff --git a/gdk/win32/gdkmain-win32.c b/gdk/win32/gdkmain-win32.c index f36be88830..ae1c8667fd 100644 --- a/gdk/win32/gdkmain-win32.c +++ b/gdk/win32/gdkmain-win32.c @@ -34,6 +34,7 @@ #include #include "gdk.h" +#include "gdkregion-generic.h" #include "gdkkeysyms.h" #include "gdkinternals.h" #include "gdkprivate-win32.h" @@ -41,27 +42,35 @@ #include +#if defined (__GNUC__) && defined (HAVE_DIMM_H) +/* The w32api imm.h clashes a bit with the IE5.5 dimm.h */ +# define IMEMENUITEMINFOA hidden_IMEMENUITEMINFOA +# define IMEMENUITEMINFOW hidden_IMEMENUITEMINFOW +#endif + +#include + static gboolean gdk_synchronize = FALSE; GdkArgDesc _gdk_windowing_args[] = { { "sync", GDK_ARG_BOOL, &gdk_synchronize, (GdkArgFunc) NULL}, - { "no-wintab", GDK_ARG_BOOL, &gdk_input_ignore_wintab, + { "no-wintab", GDK_ARG_BOOL, &_gdk_input_ignore_wintab, (GdkArgFunc) NULL}, - { "ignore-wintab", GDK_ARG_BOOL, &gdk_input_ignore_wintab, + { "ignore-wintab", GDK_ARG_BOOL, &_gdk_input_ignore_wintab, (GdkArgFunc) NULL}, { "event-func-from-window-proc", - GDK_ARG_BOOL, &gdk_event_func_from_window_proc, + GDK_ARG_BOOL, &_gdk_event_func_from_window_proc, (GdkArgFunc) NULL}, - { "max-colors", GDK_ARG_INT, &gdk_max_colors, (GdkArgFunc) NULL}, + { "max-colors", GDK_ARG_INT, &_gdk_max_colors, (GdkArgFunc) NULL}, { NULL } }; int __stdcall -DllMain(HINSTANCE hinstDLL, - DWORD dwReason, - LPVOID reserved) +DllMain (HINSTANCE hinstDLL, + DWORD dwReason, + LPVOID reserved) { - gdk_dll_hinstance = hinstDLL; + _gdk_dll_hinstance = hinstDLL; return TRUE; } @@ -74,39 +83,39 @@ _gdk_windowing_init (gint *argc, #ifdef HAVE_WINTAB if (getenv ("GDK_IGNORE_WINTAB") != NULL) - gdk_input_ignore_wintab = TRUE; + _gdk_input_ignore_wintab = TRUE; #endif if (getenv ("GDK_EVENT_FUNC_FROM_WINDOW_PROC") != NULL) - gdk_event_func_from_window_proc = TRUE; + _gdk_event_func_from_window_proc = TRUE; if (gdk_synchronize) GdiSetBatchLimit (1); - gdk_app_hmodule = GetModuleHandle (NULL); - gdk_display_hdc = CreateDC ("DISPLAY", NULL, NULL, NULL); - gdk_root_window = GetDesktopWindow (); - windows_version = GetVersion (); + _gdk_app_hmodule = GetModuleHandle (NULL); + _gdk_display_hdc = CreateDC ("DISPLAY", NULL, NULL, NULL); + _gdk_root_window = GetDesktopWindow (); + _windows_version = GetVersion (); _gdk_input_locale = GetKeyboardLayout (0); GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT), LOCALE_IDEFAULTANSICODEPAGE, buf, sizeof (buf)); _gdk_input_codepage = atoi (buf); - GDK_NOTE (MISC, g_print ("input_locale: %p, codepage:%d\n", - _gdk_input_locale, _gdk_input_codepage)); + GDK_NOTE (EVENTS, g_print ("input_locale: %p, codepage:%d\n", + _gdk_input_locale, _gdk_input_codepage)); CoInitialize (NULL); - cf_rtf = RegisterClipboardFormat ("Rich Text Format"); - cf_utf8_string = RegisterClipboardFormat ("UTF8_STRING"); + _cf_rtf = RegisterClipboardFormat ("Rich Text Format"); + _cf_utf8_string = RegisterClipboardFormat ("UTF8_STRING"); - utf8_string = gdk_atom_intern ("UTF8_STRING", FALSE); - compound_text = gdk_atom_intern ("COMPOUND_TEXT", FALSE); - text_uri_list = gdk_atom_intern ("text/uri-list", FALSE); + _utf8_string = gdk_atom_intern ("UTF8_STRING", FALSE); + _compound_text = gdk_atom_intern ("COMPOUND_TEXT", FALSE); + _text_uri_list = gdk_atom_intern ("text/uri-list", FALSE); - local_dnd = gdk_atom_intern ("LocalDndSelection", FALSE); - gdk_win32_dropfiles = gdk_atom_intern ("DROPFILES_DND", FALSE); - gdk_ole2_dnd = gdk_atom_intern ("OLE2_DND", FALSE); + _local_dnd = gdk_atom_intern ("LocalDndSelection", FALSE); + _gdk_win32_dropfiles = gdk_atom_intern ("DROPFILES_DND", FALSE); + _gdk_ole2_dnd = gdk_atom_intern ("OLE2_DND", FALSE); _gdk_selection_property = gdk_atom_intern ("GDK_SELECTION", FALSE); @@ -114,7 +123,7 @@ _gdk_windowing_init (gint *argc, } void -gdk_win32_api_failed (const gchar *where, +_gdk_win32_api_failed (const gchar *where, gint line, const gchar *api) { @@ -124,7 +133,7 @@ gdk_win32_api_failed (const gchar *where, } void -gdk_other_api_failed (const gchar *where, +_gdk_other_api_failed (const gchar *where, gint line, const gchar *api) { @@ -132,7 +141,7 @@ gdk_other_api_failed (const gchar *where, } void -gdk_win32_gdi_failed (const gchar *where, +_gdk_win32_gdi_failed (const gchar *where, gint line, const gchar *api) { @@ -140,9 +149,9 @@ gdk_win32_gdi_failed (const gchar *where, * don't set the 32-bit error code, sigh. */ if (IS_WIN_NT ()) - gdk_win32_api_failed (where, line, api); + _gdk_win32_api_failed (where, line, api); else - gdk_other_api_failed (where, line, api); + _gdk_other_api_failed (where, line, api); } void @@ -171,13 +180,13 @@ gdk_screen_get_height (GdkScreen *screen) gint gdk_screen_get_width_mm (GdkScreen *screen) { - return (double) GetDeviceCaps (gdk_display_hdc, HORZRES) / GetDeviceCaps (gdk_display_hdc, LOGPIXELSX) * 25.4; + return (double) GetDeviceCaps (_gdk_display_hdc, HORZRES) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSX) * 25.4; } gint gdk_screen_get_height_mm (GdkScreen *screen) { - return (double) GetDeviceCaps (gdk_display_hdc, VERTRES) / GetDeviceCaps (gdk_display_hdc, LOGPIXELSY) * 25.4; + return (double) GetDeviceCaps (_gdk_display_hdc, VERTRES) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSY) * 25.4; } void @@ -199,8 +208,8 @@ _gdk_windowing_exit (void) { _gdk_win32_dnd_exit (); CoUninitialize (); - DeleteDC (gdk_display_hdc); - gdk_display_hdc = NULL; + DeleteDC (_gdk_display_hdc); + _gdk_display_hdc = NULL; } void @@ -218,3 +227,616 @@ void gdk_notify_startup_complete (void) { } + +#ifdef G_ENABLE_DEBUG + +/* + * Like g_strdup_printf, but to a static buffer. Return value does not + * have to be g_free()d. The buffer is of bounded size and reused + * cyclically. Thus the return value is valid only until that part of + * the buffer happens to get reused. This doesn't matter as this + * function's return value is used in debugging output right after the call, + * and the return value isn't used after that. + */ +static gchar * +static_printf (const gchar *format, + ...) +{ + static gchar buf[10000]; + gchar *msg; + static gchar *bufp = buf; + gchar *retval; + va_list args; + + va_start (args, format); + msg = g_strdup_vprintf (format, args); + va_end (args); + + g_assert (strlen (msg) < sizeof (buf)); + + if (bufp + strlen (msg) + 1 > buf + sizeof (buf)) + bufp = buf; + retval = bufp; + + strcpy (bufp, msg); + bufp += strlen (msg) + 1; + g_free (msg); + + return retval; +} + +gchar * +_gdk_win32_color_to_string (const GdkColor *color) +{ + return static_printf ("(%.04x,%.04x,%.04x):%.06x", + color->red, color->green, + color->blue, color->pixel); +} + +void +_gdk_win32_print_paletteentries (const PALETTEENTRY *pep, + const int nentries) +{ + char buf[20]; + int i; + + for (i = 0; i < nentries; i++) + g_print (" %3d %02x: %02x %02x %02x%s\n", + i, i, + pep[i].peRed, pep[i].peGreen, pep[i].peBlue, + (pep[i].peFlags == 0 ? "" : + (pep[i].peFlags == PC_EXPLICIT ? " PC_EXPLICIT" : + (pep[i].peFlags == PC_NOCOLLAPSE ? " PC_NOCOLLAPSE" : + (pep[i].peFlags == PC_RESERVED ? " PC_RESERVED" : + (sprintf (buf, " %d", pep[i].peFlags), buf)))))); +} + +void +_gdk_win32_print_system_palette (void) +{ + PALETTEENTRY *pe; + int k; + + k = GetSystemPaletteEntries (_gdk_display_hdc, 0, 0, NULL); + pe = g_new (PALETTEENTRY, k); + k = GetSystemPaletteEntries (_gdk_display_hdc, 0, k, pe); + + if (!k) + g_print ("GetSystemPaletteEntries failed: %s\n", + g_win32_error_message (GetLastError ())); + else + { + g_print ("System palette: %d entries\n", k); + _gdk_win32_print_paletteentries (pe, k); + } + g_free (pe); +} + +static gint +palette_size (HPALETTE hpal) +{ + WORD npal = 0; + + if (!GetObject (hpal, sizeof (npal), &npal)) + WIN32_GDI_FAILED ("GetObject (HPALETTE)"); + + return npal; +} + +void +_gdk_win32_print_hpalette (HPALETTE hpal) +{ + PALETTEENTRY *pe; + gint n, npal; + + npal = palette_size (hpal); + pe = g_new (PALETTEENTRY, npal); + n = GetPaletteEntries (hpal, 0, npal, pe); + + if (!n) + g_print ("HPALETTE %p: GetPaletteEntries failed: %s\n", + hpal, g_win32_error_message (GetLastError ())); + else + { + g_print ("HPALETTE %p: %d (%d) entries\n", hpal, n, npal); + _gdk_win32_print_paletteentries (pe, n); + } + g_free (pe); +} + +void +_gdk_win32_print_dc (HDC hdc) +{ + HGDIOBJ obj; + LOGBRUSH logbrush; + EXTLOGPEN extlogpen; + HRGN hrgn; + RECT rect; + int flag; + + g_print ("%p\n", hdc); + obj = GetCurrentObject (hdc, OBJ_BRUSH); + GetObject (obj, sizeof (LOGBRUSH), &logbrush); + g_print ("brush: style: %s color: %06lx hatch: %#lx\n", + _gdk_win32_lbstyle_to_string (logbrush.lbStyle), + logbrush.lbColor, logbrush.lbHatch); + obj = GetCurrentObject (hdc, OBJ_PEN); + GetObject (obj, sizeof (EXTLOGPEN), &extlogpen); + g_print ("pen: type: %s style: %s endcap: %s join: %s width: %d brush: %s\n", + _gdk_win32_pstype_to_string (extlogpen.elpPenStyle), + _gdk_win32_psstyle_to_string (extlogpen.elpPenStyle), + _gdk_win32_psendcap_to_string (extlogpen.elpPenStyle), + _gdk_win32_psjoin_to_string (extlogpen.elpPenStyle), + extlogpen.elpWidth, + _gdk_win32_lbstyle_to_string (extlogpen.elpBrushStyle)); + hrgn = CreateRectRgn (0, 0, 0, 0); + if ((flag = GetClipRgn (hdc, hrgn)) == -1) + WIN32_API_FAILED ("GetClipRgn"); + else if (flag == 0) + g_print ("no clip region\n"); + else if (flag == 1) + { + GetRgnBox (hrgn, &rect); + g_print ("clip region: %p bbox: %ldx%ld@+%ld+%ld\n", + hrgn, + rect.right - rect.left, + rect.bottom - rect.top, + rect.left, rect.top); + } + DeleteObject (hrgn); +} + +gchar * +_gdk_win32_cap_style_to_string (GdkCapStyle cap_style) +{ + switch (cap_style) + { +#define CASE(x) case GDK_CAP_##x: return #x + CASE (NOT_LAST); + CASE (BUTT); + CASE (ROUND); + CASE (PROJECTING); +#undef CASE + default: return static_printf ("illegal_%d", cap_style); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_fill_style_to_string (GdkFill fill) +{ + switch (fill) + { +#define CASE(x) case GDK_##x: return #x + CASE (SOLID); + CASE (TILED); + CASE (STIPPLED); + CASE (OPAQUE_STIPPLED); +#undef CASE + default: return static_printf ("illegal_%d", fill); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_function_to_string (GdkFunction function) +{ + switch (function) + { +#define CASE(x) case GDK_##x: return #x + CASE (COPY); + CASE (INVERT); + CASE (XOR); + CASE (CLEAR); + CASE (AND); + CASE (AND_REVERSE); + CASE (AND_INVERT); + CASE (NOOP); + CASE (OR); + CASE (EQUIV); + CASE (OR_REVERSE); + CASE (COPY_INVERT); + CASE (OR_INVERT); + CASE (NAND); + CASE (SET); +#undef CASE + default: return static_printf ("illegal_%d", function); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_join_style_to_string (GdkJoinStyle join_style) +{ + switch (join_style) + { +#define CASE(x) case GDK_JOIN_##x: return #x + CASE (MITER); + CASE (ROUND); + CASE (BEVEL); +#undef CASE + default: return static_printf ("illegal_%d", join_style); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_line_style_to_string (GdkLineStyle line_style) +{ + switch (line_style) + { +#define CASE(x) case GDK_LINE_##x: return #x + CASE(SOLID); + CASE(ON_OFF_DASH); + CASE(DOUBLE_DASH); +#undef CASE + default: return static_printf ("illegal_%d", line_style); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_lbstyle_to_string (UINT brush_style) +{ + switch (brush_style) + { +#define CASE(x) case BS_##x: return #x + CASE (DIBPATTERN); + CASE (DIBPATTERNPT); + CASE (HATCHED); + CASE (HOLLOW); + CASE (PATTERN); + CASE (SOLID); +#undef CASE + default: return static_printf ("illegal_%d", brush_style); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_pstype_to_string (DWORD pen_style) +{ + switch (pen_style & PS_TYPE_MASK) + { + case PS_GEOMETRIC: return "GEOMETRIC"; + case PS_COSMETIC: return "COSMETIC"; + default: return static_printf ("illegal_%d", pen_style & PS_TYPE_MASK); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_psstyle_to_string (DWORD pen_style) +{ + switch (pen_style & PS_STYLE_MASK) + { +#define CASE(x) case PS_##x: return #x + CASE (DASH); + CASE (DASHDOT); + CASE (DASHDOTDOT); + CASE (DOT); + CASE (INSIDEFRAME); + CASE (NULL); + CASE (SOLID); + CASE (USERSTYLE); +#undef CASE + default: return static_printf ("illegal_%d", pen_style & PS_STYLE_MASK); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_psendcap_to_string (DWORD pen_style) +{ + switch (pen_style & PS_ENDCAP_MASK) + { +#define CASE(x) case PS_ENDCAP_##x: return #x + CASE (FLAT); + CASE (ROUND); + CASE (SQUARE); +#undef CASE + default: return static_printf ("illegal_%d", pen_style & PS_ENDCAP_MASK); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_psjoin_to_string (DWORD pen_style) +{ + switch (pen_style & PS_JOIN_MASK) + { +#define CASE(x) case PS_JOIN_##x: return #x + CASE (BEVEL); + CASE (MITER); + CASE (ROUND); +#undef CASE + default: return static_printf ("illegal_%d", pen_style & PS_JOIN_MASK); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_message_to_string (UINT msg) +{ + switch (msg) + { +#define CASE(x) case x: return #x + CASE (WM_NULL); + CASE (WM_CREATE); + CASE (WM_DESTROY); + CASE (WM_MOVE); + CASE (WM_SIZE); + CASE (WM_ACTIVATE); + CASE (WM_SETFOCUS); + CASE (WM_KILLFOCUS); + CASE (WM_ENABLE); + CASE (WM_SETREDRAW); + CASE (WM_SETTEXT); + CASE (WM_GETTEXT); + CASE (WM_GETTEXTLENGTH); + CASE (WM_PAINT); + CASE (WM_CLOSE); + CASE (WM_QUERYENDSESSION); + CASE (WM_QUERYOPEN); + CASE (WM_ENDSESSION); + CASE (WM_QUIT); + CASE (WM_ERASEBKGND); + CASE (WM_SYSCOLORCHANGE); + CASE (WM_SHOWWINDOW); + CASE (WM_WININICHANGE); + CASE (WM_DEVMODECHANGE); + CASE (WM_ACTIVATEAPP); + CASE (WM_FONTCHANGE); + CASE (WM_TIMECHANGE); + CASE (WM_CANCELMODE); + CASE (WM_SETCURSOR); + CASE (WM_MOUSEACTIVATE); + CASE (WM_CHILDACTIVATE); + CASE (WM_QUEUESYNC); + CASE (WM_GETMINMAXINFO); + CASE (WM_PAINTICON); + CASE (WM_ICONERASEBKGND); + CASE (WM_NEXTDLGCTL); + CASE (WM_SPOOLERSTATUS); + CASE (WM_DRAWITEM); + CASE (WM_MEASUREITEM); + CASE (WM_DELETEITEM); + CASE (WM_VKEYTOITEM); + CASE (WM_CHARTOITEM); + CASE (WM_SETFONT); + CASE (WM_GETFONT); + CASE (WM_SETHOTKEY); + CASE (WM_GETHOTKEY); + CASE (WM_QUERYDRAGICON); + CASE (WM_COMPAREITEM); + CASE (WM_GETOBJECT); + CASE (WM_COMPACTING); + CASE (WM_WINDOWPOSCHANGING); + CASE (WM_WINDOWPOSCHANGED); + CASE (WM_POWER); + CASE (WM_COPYDATA); + CASE (WM_CANCELJOURNAL); + CASE (WM_NOTIFY); + CASE (WM_INPUTLANGCHANGEREQUEST); + CASE (WM_INPUTLANGCHANGE); + CASE (WM_TCARD); + CASE (WM_HELP); + CASE (WM_USERCHANGED); + CASE (WM_NOTIFYFORMAT); + CASE (WM_CONTEXTMENU); + CASE (WM_STYLECHANGING); + CASE (WM_STYLECHANGED); + CASE (WM_DISPLAYCHANGE); + CASE (WM_GETICON); + CASE (WM_SETICON); + CASE (WM_NCCREATE); + CASE (WM_NCDESTROY); + CASE (WM_NCCALCSIZE); + CASE (WM_NCHITTEST); + CASE (WM_NCPAINT); + CASE (WM_NCACTIVATE); + CASE (WM_GETDLGCODE); + CASE (WM_SYNCPAINT); + CASE (WM_NCMOUSEMOVE); + CASE (WM_NCLBUTTONDOWN); + CASE (WM_NCLBUTTONUP); + CASE (WM_NCLBUTTONDBLCLK); + CASE (WM_NCRBUTTONDOWN); + CASE (WM_NCRBUTTONUP); + CASE (WM_NCRBUTTONDBLCLK); + CASE (WM_NCMBUTTONDOWN); + CASE (WM_NCMBUTTONUP); + CASE (WM_NCMBUTTONDBLCLK); + CASE (WM_NCXBUTTONDOWN); + CASE (WM_NCXBUTTONUP); + CASE (WM_NCXBUTTONDBLCLK); + CASE (WM_KEYDOWN); + CASE (WM_KEYUP); + CASE (WM_CHAR); + CASE (WM_DEADCHAR); + CASE (WM_SYSKEYDOWN); + CASE (WM_SYSKEYUP); + CASE (WM_SYSCHAR); + CASE (WM_SYSDEADCHAR); + CASE (WM_KEYLAST); + CASE (WM_IME_STARTCOMPOSITION); + CASE (WM_IME_ENDCOMPOSITION); + CASE (WM_IME_COMPOSITION); + CASE (WM_INITDIALOG); + CASE (WM_COMMAND); + CASE (WM_SYSCOMMAND); + CASE (WM_TIMER); + CASE (WM_HSCROLL); + CASE (WM_VSCROLL); + CASE (WM_INITMENU); + CASE (WM_INITMENUPOPUP); + CASE (WM_MENUSELECT); + CASE (WM_MENUCHAR); + CASE (WM_ENTERIDLE); + CASE (WM_MENURBUTTONUP); + CASE (WM_MENUDRAG); + CASE (WM_MENUGETOBJECT); + CASE (WM_UNINITMENUPOPUP); + CASE (WM_MENUCOMMAND); + CASE (WM_CHANGEUISTATE); + CASE (WM_UPDATEUISTATE); + CASE (WM_QUERYUISTATE); + CASE (WM_CTLCOLORMSGBOX); + CASE (WM_CTLCOLOREDIT); + CASE (WM_CTLCOLORLISTBOX); + CASE (WM_CTLCOLORBTN); + CASE (WM_CTLCOLORDLG); + CASE (WM_CTLCOLORSCROLLBAR); + CASE (WM_CTLCOLORSTATIC); + CASE (WM_MOUSEMOVE); + CASE (WM_LBUTTONDOWN); + CASE (WM_LBUTTONUP); + CASE (WM_LBUTTONDBLCLK); + CASE (WM_RBUTTONDOWN); + CASE (WM_RBUTTONUP); + CASE (WM_RBUTTONDBLCLK); + CASE (WM_MBUTTONDOWN); + CASE (WM_MBUTTONUP); + CASE (WM_MBUTTONDBLCLK); + CASE (WM_MOUSEWHEEL); + CASE (WM_XBUTTONDOWN); + CASE (WM_XBUTTONUP); + CASE (WM_XBUTTONDBLCLK); + CASE (WM_PARENTNOTIFY); + CASE (WM_ENTERMENULOOP); + CASE (WM_EXITMENULOOP); + CASE (WM_NEXTMENU); + CASE (WM_SIZING); + CASE (WM_CAPTURECHANGED); + CASE (WM_MOVING); + CASE (WM_POWERBROADCAST); + CASE (WM_DEVICECHANGE); + CASE (WM_MDICREATE); + CASE (WM_MDIDESTROY); + CASE (WM_MDIACTIVATE); + CASE (WM_MDIRESTORE); + CASE (WM_MDINEXT); + CASE (WM_MDIMAXIMIZE); + CASE (WM_MDITILE); + CASE (WM_MDICASCADE); + CASE (WM_MDIICONARRANGE); + CASE (WM_MDIGETACTIVE); + CASE (WM_MDISETMENU); + CASE (WM_ENTERSIZEMOVE); + CASE (WM_EXITSIZEMOVE); + CASE (WM_DROPFILES); + CASE (WM_MDIREFRESHMENU); + CASE (WM_IME_SETCONTEXT); + CASE (WM_IME_NOTIFY); + CASE (WM_IME_CONTROL); + CASE (WM_IME_COMPOSITIONFULL); + CASE (WM_IME_SELECT); + CASE (WM_IME_CHAR); + CASE (WM_IME_REQUEST); + CASE (WM_IME_KEYDOWN); + CASE (WM_IME_KEYUP); + CASE (WM_MOUSEHOVER); + CASE (WM_MOUSELEAVE); + CASE (WM_NCMOUSEHOVER); + CASE (WM_NCMOUSELEAVE); + CASE (WM_CUT); + CASE (WM_COPY); + CASE (WM_PASTE); + CASE (WM_CLEAR); + CASE (WM_UNDO); + CASE (WM_RENDERFORMAT); + CASE (WM_RENDERALLFORMATS); + CASE (WM_DESTROYCLIPBOARD); + CASE (WM_DRAWCLIPBOARD); + CASE (WM_PAINTCLIPBOARD); + CASE (WM_VSCROLLCLIPBOARD); + CASE (WM_SIZECLIPBOARD); + CASE (WM_ASKCBFORMATNAME); + CASE (WM_CHANGECBCHAIN); + CASE (WM_HSCROLLCLIPBOARD); + CASE (WM_QUERYNEWPALETTE); + CASE (WM_PALETTEISCHANGING); + CASE (WM_PALETTECHANGED); + CASE (WM_HOTKEY); + CASE (WM_PRINT); + CASE (WM_PRINTCLIENT); + CASE (WM_APPCOMMAND); + CASE (WM_HANDHELDFIRST); + CASE (WM_HANDHELDLAST); + CASE (WM_AFXFIRST); + CASE (WM_AFXLAST); + CASE (WM_PENWINFIRST); + CASE (WM_PENWINLAST); + CASE (WM_APP); +#undef CASE + default: + if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST) + return static_printf ("WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST); + else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST) + return static_printf ("WM_AFXFIRST+%d", msg - WM_AFXFIRST); + else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST) + return static_printf ("WM_PENWINFIRST+%d", msg - WM_PENWINFIRST); + else if (msg >= WM_USER && msg <= 0x7FFF) + return static_printf ("WM_USER+%d", msg - WM_USER); + else if (msg >= 0xC000 && msg <= 0xFFFF) + return static_printf ("reg-%#x", msg); + else + return static_printf ("unk-%#x", msg); + } + /* NOTREACHED */ + return NULL; +} + +gchar * +_gdk_win32_rect_to_string (const RECT *rect) +{ + return static_printf ("%ldx%ld@+%ld+%ld", + (rect->right - rect->left), (rect->bottom - rect->top), + rect->left, rect->top); +} + +gchar * +_gdk_win32_gdkrectangle_to_string (const GdkRectangle *rect) +{ + return static_printf ("%dx%d@+%d+%d", + rect->width, rect->height, + rect->x, rect->y); +} + +gchar * +_gdk_win32_gdkregion_to_string (const GdkRegion *rgn) +{ + return static_printf ("%dx%d@+%d+%d", + (rgn->extents.x2 - rgn->extents.x1), + (rgn->extents.y2 - rgn->extents.y1), + rgn->extents.x1, rgn->extents.y1); +} + +gchar * +_gdk_win32_drawable_description (GdkDrawable *d) +{ + GdkVisual *v; + gint width, height; + + gdk_drawable_get_size (d, &width, &height); + + return static_printf + ("%s:%p:%dx%dx%d", + G_OBJECT_TYPE_NAME (d), + GDK_DRAWABLE_HANDLE (d), + width, height, + (GDK_IS_PIXMAP (d) ? GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (d)->impl)->image->depth + : ((v = gdk_drawable_get_visual (d)) ? v->depth : gdk_visual_get_system ()->depth))); +} + +#endif /* G_ENABLE_DEBUG */ diff --git a/gdk/win32/gdkprivate-win32.h b/gdk/win32/gdkprivate-win32.h index a3120465bb..a6959c987d 100644 --- a/gdk/win32/gdkprivate-win32.h +++ b/gdk/win32/gdkprivate-win32.h @@ -263,11 +263,7 @@ struct _GdkGCWin32 * window or pixmap. We thus keep all the necessary values in the * GdkGCWin32 object. */ - HDC hdc; - int saved_dc; - - GdkRegion *clip_region; HRGN hcliprgn; GdkGCValuesMask values_mask; @@ -286,8 +282,13 @@ struct _GdkGCWin32 DWORD pen_style; DWORD *pen_dashes; /* use for PS_USERSTYLE or step-by-step rendering */ gint pen_num_dashes; - HANDLE hwnd; /* If a HDC is allocated, for which window, - * or what bitmap is selected into it + + /* Following fields are valid while the GC exists as a Windows DC */ + HDC hdc; + int saved_dc; + + HANDLE hwnd; /* For which window, or what bitmap is + * selected into it */ HPALETTE holdpal; }; @@ -299,25 +300,16 @@ struct _GdkGCWin32Class GType _gdk_gc_win32_get_type (void); -/* Routines from gdkgeometry-win32.c */ +gulong _gdk_win32_get_next_tick (gulong suggested_tick); + void _gdk_window_init_position (GdkWindow *window); void _gdk_window_move_resize_child (GdkWindow *window, gint x, gint y, gint width, gint height); -void _gdk_window_process_expose (GdkWindow *window, - gulong serial, - GdkRectangle *area); - -/* gdkdrawable-win32.c, background draw helper */ -void _gdk_win32_draw_tiles (GdkDrawable *drawable, - GdkGC *gc, - GdkPixmap *tile, - gint x, - gint y, - gint width, - gint height); +void _gdk_window_process_expose (GdkWindow *window, + GdkRegion *invalidate_region); void _gdk_win32_selection_init (void); void _gdk_win32_dnd_exit (void); @@ -372,9 +364,11 @@ void _gdk_win32_blit (gboolean use_fg_bg, COLORREF _gdk_win32_colormap_color (GdkColormap *colormap, gulong pixel); -HRGN _gdk_win32_bitmap_to_region (GdkPixmap *bitmap); +HRGN _gdk_win32_bitmap_to_hrgn (GdkPixmap *bitmap); -gchar *gdk_font_full_name_get (GdkFont *font); +HRGN _gdk_win32_gdkregion_to_hrgn (GdkRegion *region, + gint x_origin, + gint y_origin); void _gdk_selection_property_store (GdkWindow *owner, GdkAtom type, @@ -404,48 +398,62 @@ void _gdk_wchar_text_handle (GdkFont *font, void *arg); #ifdef G_ENABLE_DEBUG -gchar *gdk_win32_color_to_string (const GdkColor *color); -gchar *gdk_win32_cap_style_to_string (GdkCapStyle cap_style); -gchar *gdk_win32_fill_style_to_string (GdkFill fill); -gchar *gdk_win32_function_to_string (GdkFunction function); -gchar *gdk_win32_join_style_to_string (GdkJoinStyle join_style); -gchar *gdk_win32_line_style_to_string (GdkLineStyle line_style); -gchar *gdk_win32_message_name (UINT msg); +gchar *_gdk_win32_color_to_string (const GdkColor *color); +void _gdk_win32_print_paletteentries (const PALETTEENTRY *pep, + const int nentries); +void _gdk_win32_print_system_palette (void); +void _gdk_win32_print_hpalette (HPALETTE hpal); +void _gdk_win32_print_dc (HDC hdc); + +gchar *_gdk_win32_cap_style_to_string (GdkCapStyle cap_style); +gchar *_gdk_win32_fill_style_to_string (GdkFill fill); +gchar *_gdk_win32_function_to_string (GdkFunction function); +gchar *_gdk_win32_join_style_to_string (GdkJoinStyle join_style); +gchar *_gdk_win32_line_style_to_string (GdkLineStyle line_style); +gchar *_gdk_win32_drawable_description (GdkDrawable *d); + +gchar *_gdk_win32_lbstyle_to_string (UINT brush_style); +gchar *_gdk_win32_pstype_to_string (DWORD pen_style); +gchar *_gdk_win32_psstyle_to_string (DWORD pen_style); +gchar *_gdk_win32_psendcap_to_string (DWORD pen_style); +gchar *_gdk_win32_psjoin_to_string (DWORD pen_style); +gchar *_gdk_win32_message_to_string (UINT msg); +gchar *_gdk_win32_rect_to_string (const RECT *rect); + +gchar *_gdk_win32_gdkrectangle_to_string (const GdkRectangle *rect); +gchar *_gdk_win32_gdkregion_to_string (const GdkRegion *box); -#define PING() printf(G_STRLOC),fflush(stdout) -#else -#define PING() #endif -gchar *gdk_win32_last_error_string (void); -void gdk_win32_api_failed (const gchar *where, +gchar *_gdk_win32_last_error_string (void); +void _gdk_win32_api_failed (const gchar *where, gint line, const gchar *api); -void gdk_other_api_failed (const gchar *where, +void _gdk_other_api_failed (const gchar *where, gint line, const gchar *api); -void gdk_win32_gdi_failed (const gchar *where, +void _gdk_win32_gdi_failed (const gchar *where, gint line, const gchar *api); #ifdef __GNUC__ -#define WIN32_API_FAILED(api) gdk_win32_api_failed (__FILE__ ":" __PRETTY_FUNCTION__, __LINE__, api) -#define WIN32_GDI_FAILED(api) gdk_win32_gdi_failed (__FILE__ ":" __PRETTY_FUNCTION__, __LINE__, api) -#define OTHER_API_FAILED(api) gdk_other_api_failed (__FILE__ ":" __PRETTY_FUNCTION__, __LINE__, api) +#define WIN32_API_FAILED(api) _gdk_win32_api_failed (__FILE__ ":" __PRETTY_FUNCTION__, __LINE__, api) +#define WIN32_GDI_FAILED(api) _gdk_win32_gdi_failed (__FILE__ ":" __PRETTY_FUNCTION__, __LINE__, api) +#define OTHER_API_FAILED(api) _gdk_other_api_failed (__FILE__ ":" __PRETTY_FUNCTION__, __LINE__, api) #else -#define WIN32_API_FAILED(api) gdk_win32_api_failed (__FILE__, __LINE__, api) -#define WIN32_GDI_FAILED(api) gdk_win32_gdi_failed (__FILE__, __LINE__, api) -#define OTHER_API_FAILED(api) gdk_other_api_failed (__FILE__, __LINE__, api) +#define WIN32_API_FAILED(api) _gdk_win32_api_failed (__FILE__, __LINE__, api) +#define WIN32_GDI_FAILED(api) _gdk_win32_gdi_failed (__FILE__, __LINE__, api) +#define OTHER_API_FAILED(api) _gdk_other_api_failed (__FILE__, __LINE__, api) #endif extern LRESULT CALLBACK _gdk_win32_window_procedure (HWND, UINT, WPARAM, LPARAM); -extern HWND gdk_root_window; +extern HWND _gdk_root_window; extern GdkWindow *_gdk_parent_root; -extern HDC gdk_display_hdc; -extern HINSTANCE gdk_dll_hinstance; -extern HINSTANCE gdk_app_hmodule; +extern HDC _gdk_display_hdc; +extern HINSTANCE _gdk_dll_hinstance; +extern HINSTANCE _gdk_app_hmodule; /* These are thread specific, but GDK/win32 works OK only when invoked * from a single thread anyway. @@ -456,28 +464,28 @@ extern UINT _gdk_input_codepage; extern guint _gdk_keymap_serial; /* Registered clipboard formats */ -extern WORD cf_rtf; -extern WORD cf_utf8_string; +extern WORD _cf_rtf; +extern WORD _cf_utf8_string; /* GdkAtoms: Targets */ -extern GdkAtom utf8_string; -extern GdkAtom compound_text; -extern GdkAtom text_uri_list; +extern GdkAtom _utf8_string; +extern GdkAtom _compound_text; +extern GdkAtom _text_uri_list; /* DND selections */ -extern GdkAtom local_dnd; -extern GdkAtom gdk_win32_dropfiles; -extern GdkAtom gdk_ole2_dnd; +extern GdkAtom _local_dnd; +extern GdkAtom _gdk_win32_dropfiles; +extern GdkAtom _gdk_ole2_dnd; extern GdkAtom _gdk_selection_property; -extern DWORD windows_version; -#define IS_WIN_NT() (windows_version < 0x80000000) +extern DWORD _windows_version; +#define IS_WIN_NT() (_windows_version < 0x80000000) /* Options */ -extern gboolean gdk_input_ignore_wintab; -extern gboolean gdk_event_func_from_window_proc; -extern gint gdk_max_colors; +extern gboolean _gdk_input_ignore_wintab; +extern gboolean _gdk_event_func_from_window_proc; +extern gint _gdk_max_colors; #define GDK_WIN32_COLORMAP_DATA(cmap) ((GdkColormapPrivateWin32 *) GDK_COLORMAP (cmap)->windowing_data) diff --git a/gdk/win32/gdkproperty-win32.c b/gdk/win32/gdkproperty-win32.c index d92cb3b6c3..5e543b818a 100644 --- a/gdk/win32/gdkproperty-win32.c +++ b/gdk/win32/gdkproperty-win32.c @@ -425,7 +425,7 @@ gdk_property_change (GdkWindow *window, break; case RICH_TEXT: - cf = cf_rtf; + cf = _cf_rtf; memmove (ucptr, rtf->str, size); g_string_free (rtf, TRUE); @@ -439,7 +439,7 @@ gdk_property_change (GdkWindow *window, guchar *utf8ptr = GlobalLock (hutf8); memmove (utf8ptr, data, nelements); GlobalUnlock (hutf8); - if (!SetClipboardData (cf_utf8_string, hutf8)) + if (!SetClipboardData (_cf_utf8_string, hutf8)) WIN32_API_FAILED ("SetClipboardData (UTF8_STRING)"); } break; diff --git a/gdk/win32/gdkscreen-win32.c b/gdk/win32/gdkscreen-win32.c index c5455bd3b9..84bdd10aaf 100644 --- a/gdk/win32/gdkscreen-win32.c +++ b/gdk/win32/gdkscreen-win32.c @@ -82,8 +82,8 @@ gdk_screen_get_number (GdkScreen *screen) } gchar * -_gdk_windowing_substitute_screen_number (gchar *display_name, - int screen_number) +_gdk_windowing_substitute_screen_number (const gchar *display_name, + int screen_number) { return g_strdup (display_name); } diff --git a/gdk/win32/gdkselection-win32.c b/gdk/win32/gdkselection-win32.c index 98f1a8db0b..45fd1f808e 100644 --- a/gdk/win32/gdkselection-win32.c +++ b/gdk/win32/gdkselection-win32.c @@ -95,7 +95,7 @@ _gdk_dropfiles_store (gchar *data) dropfiles_prop->data = data; dropfiles_prop->length = strlen (data); dropfiles_prop->format = 8; - dropfiles_prop->type = text_uri_list; + dropfiles_prop->type = _text_uri_list; } else { @@ -280,7 +280,7 @@ gdk_selection_convert (GdkWindow *requestor, } if (IsClipboardFormatAvailable (CF_UNICODETEXT) || - IsClipboardFormatAvailable (cf_utf8_string) || + IsClipboardFormatAvailable (_cf_utf8_string) || IsClipboardFormatAvailable (CF_TEXT)) { GdkAtom *data = g_new (GdkAtom, 1); @@ -292,7 +292,7 @@ gdk_selection_convert (GdkWindow *requestor, property = GDK_NONE; } else if (selection == GDK_SELECTION_CLIPBOARD && - (target == compound_text || + (target == _compound_text || target == GDK_TARGET_STRING)) { /* Converting the CLIPBOARD selection means he wants the @@ -342,7 +342,7 @@ gdk_selection_convert (GdkWindow *requestor, GlobalUnlock (hdata); } } - else if ((hdata = GetClipboardData (cf_utf8_string)) != NULL) + else if ((hdata = GetClipboardData (_cf_utf8_string)) != NULL) { /* UTF8_STRING is a format we store ourselves when necessary */ guchar *ptr; @@ -426,7 +426,7 @@ gdk_selection_convert (GdkWindow *requestor, CloseClipboard (); } - else if (selection == gdk_win32_dropfiles) + else if (selection == _gdk_win32_dropfiles) { /* This means he wants the names of the dropped files. * gdk_dropfiles_filter already has stored the text/uri-list @@ -609,7 +609,7 @@ gdk_string_to_compound_text_for_display (GdkDisplay *display, GDK_NOTE (DND, g_print ("gdk_string_to_compound_text: %.20s\n", str)); if (encoding) - *encoding = compound_text; + *encoding = _compound_text; if (format) *format = 8; @@ -720,7 +720,7 @@ gdk_text_property_to_utf8_list_for_display (GdkDisplay *display, { return make_list ((gchar *)text, length, TRUE, list); } - else if (encoding == utf8_string) + else if (encoding == _utf8_string) { return make_list ((gchar *)text, length, FALSE, list); } diff --git a/gdk/win32/gdkvisual-win32.c b/gdk/win32/gdkvisual-win32.c index c1a09e77ac..fb78c25066 100644 --- a/gdk/win32/gdkvisual-win32.c +++ b/gdk/win32/gdkvisual-win32.c @@ -95,16 +95,16 @@ _gdk_visual_init (void) } bmi; HBITMAP hbm; - const gint rastercaps = GetDeviceCaps (gdk_display_hdc, RASTERCAPS); - gint bitspixel = GetDeviceCaps (gdk_display_hdc, BITSPIXEL); + const gint rastercaps = GetDeviceCaps (_gdk_display_hdc, RASTERCAPS); + gint bitspixel = GetDeviceCaps (_gdk_display_hdc, BITSPIXEL); gint map_entries = 0; system_visual = g_object_new (GDK_TYPE_VISUAL, NULL); if (rastercaps & RC_PALETTE) { - const int sizepalette = GetDeviceCaps (gdk_display_hdc, SIZEPALETTE); - const int numcolors = GetDeviceCaps (gdk_display_hdc, NUMCOLORS); + const int sizepalette = GetDeviceCaps (_gdk_display_hdc, SIZEPALETTE); + const int numcolors = GetDeviceCaps (_gdk_display_hdc, NUMCOLORS); gchar *max_colors = getenv ("GDK_WIN32_MAX_COLORS"); system_visual->type = GDK_VISUAL_PSEUDO_COLOR; @@ -113,9 +113,9 @@ _gdk_visual_init (void) g_assert (sizepalette == 256); if (max_colors != NULL) - gdk_max_colors = atoi (max_colors); + _gdk_max_colors = atoi (max_colors); - map_entries = gdk_max_colors; + map_entries = _gdk_max_colors; if (map_entries >= 16 && map_entries < sizepalette) { @@ -179,10 +179,10 @@ _gdk_visual_init (void) memset (&bmi, 0, sizeof (bmi)); bmi.bi.biSize = sizeof (bmi.bi); - hbm = CreateCompatibleBitmap (gdk_display_hdc, 1, 1); - GetDIBits (gdk_display_hdc, hbm, 0, 1, NULL, + hbm = CreateCompatibleBitmap (_gdk_display_hdc, 1, 1); + GetDIBits (_gdk_display_hdc, hbm, 0, 1, NULL, (BITMAPINFO *) &bmi, DIB_RGB_COLORS); - GetDIBits (gdk_display_hdc, hbm, 0, 1, NULL, + GetDIBits (_gdk_display_hdc, hbm, 0, 1, NULL, (BITMAPINFO *) &bmi, DIB_RGB_COLORS); DeleteObject (hbm); diff --git a/gdk/win32/gdkwindow-win32.c b/gdk/win32/gdkwindow-win32.c index 273cf5a246..9907637706 100644 --- a/gdk/win32/gdkwindow-win32.c +++ b/gdk/win32/gdkwindow-win32.c @@ -35,10 +35,6 @@ #include "gdkprivate-win32.h" #include "gdkinput-win32.h" -static gboolean gdk_window_gravity_works (void); -static void gdk_window_set_static_win_gravity (GdkWindow *window, - gboolean on); - static GdkColormap* gdk_window_impl_win32_get_colormap (GdkDrawable *drawable); static void gdk_window_impl_win32_set_colormap (GdkDrawable *drawable, GdkColormap *cmap); @@ -240,7 +236,7 @@ _gdk_windowing_window_init (void) impl = GDK_WINDOW_IMPL_WIN32 (private->impl); draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl); - draw_impl->handle = gdk_root_window; + draw_impl->handle = _gdk_root_window; draw_impl->wrapper = GDK_DRAWABLE (private); draw_impl->colormap = gdk_colormap_get_system (); gdk_colormap_ref (draw_impl->colormap); @@ -250,7 +246,22 @@ _gdk_windowing_window_init (void) impl->width = width; impl->height = height; - gdk_win32_handle_table_insert (&gdk_root_window, _gdk_parent_root); + _gdk_window_init_position (GDK_WINDOW (private)); + + gdk_win32_handle_table_insert (&_gdk_root_window, _gdk_parent_root); +} + +static const gchar * +get_default_title (void) +{ + const char *title; +#if 0 /* So that we can build with GLib 2.0... */ + title = g_get_application_name (); + if (!title) +#endif + title = g_get_prgname (); + + return title; } /* The Win API function AdjustWindowRect may return negative values @@ -305,20 +316,20 @@ RegisterGdkClass (GdkWindowType wtype) wcl.lpfnWndProc = _gdk_win32_window_procedure; wcl.cbClsExtra = 0; wcl.cbWndExtra = 0; - wcl.hInstance = gdk_app_hmodule; + wcl.hInstance = _gdk_app_hmodule; wcl.hIcon = 0; /* initialize once! */ if (0 == hAppIcon) { gchar sLoc [MAX_PATH+1]; - if (0 != GetModuleFileName (gdk_app_hmodule, sLoc, MAX_PATH)) + if (0 != GetModuleFileName (_gdk_app_hmodule, sLoc, MAX_PATH)) { - hAppIcon = ExtractIcon (gdk_app_hmodule, sLoc, 0); + hAppIcon = ExtractIcon (_gdk_app_hmodule, sLoc, 0); if (0 == hAppIcon) { - if (0 != GetModuleFileName (gdk_dll_hinstance, sLoc, MAX_PATH)) - hAppIcon = ExtractIcon (gdk_dll_hinstance, sLoc, 0); + if (0 != GetModuleFileName (_gdk_dll_hinstance, sLoc, MAX_PATH)) + hAppIcon = ExtractIcon (_gdk_dll_hinstance, sLoc, 0); } } if (0 == hAppIcon) @@ -484,7 +495,7 @@ gdk_window_new (GdkWindow *parent, if (attributes_mask & GDK_WA_TITLE) title = attributes->title; else - title = g_get_prgname (); + title = get_default_title (); if (!title || !*title) title = "GDK client window"; @@ -529,7 +540,7 @@ gdk_window_new (GdkWindow *parent, { case GDK_WINDOW_TOPLEVEL: dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN; - hparent = gdk_root_window; + hparent = _gdk_root_window; break; case GDK_WINDOW_CHILD: @@ -541,7 +552,7 @@ gdk_window_new (GdkWindow *parent, #if 0 dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */ #endif - hparent = gdk_root_window; + hparent = _gdk_root_window; break; case GDK_WINDOW_TEMP: @@ -601,7 +612,7 @@ gdk_window_new (GdkWindow *parent, impl->position_info.width, impl->position_info.height, hparent, NULL, - gdk_app_hmodule, + _gdk_app_hmodule, NULL); #else { @@ -614,7 +625,7 @@ gdk_window_new (GdkWindow *parent, impl->position_info.width, impl->position_info.height, hparent, NULL, - gdk_app_hmodule, + _gdk_app_hmodule, window); if (GDK_WINDOW_HWND (window) != hwndNew) { @@ -703,7 +714,7 @@ gdk_window_foreign_new_for_display (GdkDisplay *display, point.x = rect.left; point.y = rect.right; ClientToScreen ((HWND) anid, &point); - if (parent != gdk_root_window) + if (parent != _gdk_root_window) ScreenToClient (parent, &point); private->x = point.x; private->y = point.y; @@ -718,6 +729,8 @@ gdk_window_foreign_new_for_display (GdkDisplay *display, private->state |= GDK_WINDOW_STATE_WITHDRAWN; private->depth = gdk_visual_get_system ()->depth; + _gdk_window_init_position (GDK_WINDOW (private)); + gdk_drawable_ref (window); gdk_win32_handle_table_insert (&GDK_WINDOW_HWND (window), window); @@ -1111,11 +1124,13 @@ gdk_window_reparent (GdkWindow *window, old_parent_private->children = g_list_remove (old_parent_private->children, window); +#if 0 if ((old_parent_private && (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) || (!old_parent_private && parent_private->guffaw_gravity)) gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity); - +#endif + parent_private->children = g_list_prepend (parent_private->children, window); _gdk_window_init_position (GDK_WINDOW (window_private)); } @@ -1546,7 +1561,7 @@ gdk_window_set_background (GdkWindow *window, GDK_NOTE (MISC, g_print ("gdk_window_set_background: %p %s\n", GDK_WINDOW_HWND (window), - gdk_win32_color_to_string (color))); + _gdk_win32_color_to_string (color))); private->bg_color = *color; @@ -1705,6 +1720,26 @@ gdk_window_get_geometry (GdkWindow *window, if (!GetClientRect (GDK_WINDOW_HWND (window), &rect)) WIN32_API_FAILED ("GetClientRect"); + if (window != _gdk_parent_root) + { + POINT pt; + GdkWindow *parent = gdk_window_get_parent (window); + + pt.x = rect.left; + pt.y = rect.top; + ClientToScreen (GDK_WINDOW_HWND (window), &pt); + ScreenToClient (GDK_WINDOW_HWND (parent), &pt); + rect.left = pt.x; + rect.top = pt.y; + + pt.x = rect.right; + pt.y = rect.bottom; + ClientToScreen (GDK_WINDOW_HWND (window), &pt); + ScreenToClient (GDK_WINDOW_HWND (parent), &pt); + rect.right = pt.x; + rect.bottom = pt.y; + } + if (x) *x = rect.left; if (y) @@ -1823,7 +1858,8 @@ gdk_window_get_frame_extents (GdkWindow *window, } GdkWindow* -_gdk_windowing_window_get_pointer (GdkWindow *window, +_gdk_windowing_window_get_pointer (GdkDisplay *display, + GdkWindow *window, gint *x, gint *y, GdkModifierType *mask) @@ -1894,10 +1930,10 @@ _gdk_windowing_get_pointer (GdkDisplay *display, GdkModifierType *mask) { GdkScreen *default_screen = gdk_display_get_default_screen (display); - GdkWindow *root_window = gdk_screen_get_root_window (screen); + GdkWindow *root_window = gdk_screen_get_root_window (default_screen); *screen = default_screen; - _gdk_windowing_window_get_pointer (root_window, x, y, mask); + _gdk_windowing_window_get_pointer (display, root_window, x, y, mask); } GdkWindow* @@ -1998,7 +2034,7 @@ gdk_window_shape_combine_mask (GdkWindow *window, RECT rect; /* Convert mask bitmap to region */ - hrgn = _gdk_win32_bitmap_to_region (mask); + hrgn = _gdk_win32_bitmap_to_hrgn (mask); GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %p %p\n", GDK_WINDOW_HWND (window), @@ -2249,6 +2285,7 @@ gdk_propagate_shapes (HANDLE win, } } SetWindowRgn (win, region, TRUE); + g_free (list); } else DeleteObject (region); @@ -2278,91 +2315,11 @@ gdk_window_merge_child_shapes (GdkWindow *window) gdk_propagate_shapes (GDK_WINDOW_HWND (window), TRUE); } -/* Support for windows that can be guffaw-scrolled - * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt) - */ - -static gboolean -gdk_window_gravity_works (void) -{ - enum { UNKNOWN, NO, YES }; - static gint gravity_works = UNKNOWN; - - if (gravity_works == UNKNOWN) - { - GdkWindowAttr attr; - GdkWindow *parent; - GdkWindow *child; - gint y; - - attr.window_type = GDK_WINDOW_TEMP; - attr.wclass = GDK_INPUT_OUTPUT; - attr.x = 0; - attr.y = 0; - attr.width = 100; - attr.height = 100; - attr.event_mask = 0; - - parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y); - - attr.window_type = GDK_WINDOW_CHILD; - child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y); - - gdk_window_set_static_win_gravity (child, TRUE); - - gdk_window_resize (parent, 100, 110); - gdk_window_move (parent, 0, -10); - gdk_window_move_resize (parent, 0, 0, 100, 100); - - gdk_window_resize (parent, 100, 110); - gdk_window_move (parent, 0, -10); - gdk_window_move_resize (parent, 0, 0, 100, 100); - - gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL); - - gdk_window_destroy (parent); - gdk_window_destroy (child); - - gravity_works = ((y == -20) ? YES : NO); - } - - return (gravity_works == YES); -} - -static void -gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on) -{ - g_return_if_fail (window != NULL); - - GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n")); -} - -static void -gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on) -{ - g_return_if_fail (window != NULL); - - GDK_NOTE (MISC, g_print ("gdk_window_set_static_win_gravity: Not implemented\n")); -} - -/************************************************************* - * gdk_window_set_static_gravities: - * Set the bit gravity of the given window to static, - * and flag it so all children get static subwindow - * gravity. - * arguments: - * window: window for which to set static gravity - * use_static: Whether to turn static gravity on or off. - * results: - * Does the XServer support static gravity? - *************************************************************/ - gboolean gdk_window_set_static_gravities (GdkWindow *window, gboolean use_static) { GdkWindowObject *private = (GdkWindowObject *)window; - GList *tmp_list; g_return_val_if_fail (window != NULL, FALSE); g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE); @@ -2370,24 +2327,11 @@ gdk_window_set_static_gravities (GdkWindow *window, if (!use_static == !private->guffaw_gravity) return TRUE; - if (use_static && !gdk_window_gravity_works ()) + if (use_static) return FALSE; private->guffaw_gravity = use_static; - if (!GDK_WINDOW_DESTROYED (window)) - { - gdk_window_set_static_bit_gravity (window, use_static); - - tmp_list = private->children; - while (tmp_list) - { - gdk_window_set_static_win_gravity (window, use_static); - - tmp_list = tmp_list->next; - } - } - return TRUE; } @@ -2579,7 +2523,7 @@ gdk_window_set_type_hint (GdkWindow *window, /* * XXX ??? */ - GDK_NOTE (MISC, g_print ("gdk_window_set_type_hint (%p)\n", + GDK_NOTE (MISC, g_print ("gdk_window_set_type_hint: %p\n", GDK_WINDOW_HWND (window))); } diff --git a/gdk/win32/rc/gdk.rc.in b/gdk/win32/rc/gdk.rc.in index 6e15a2e37e..cf5da2cfe4 100644 --- a/gdk/win32/rc/gdk.rc.in +++ b/gdk/win32/rc/gdk.rc.in @@ -19,7 +19,7 @@ VS_VERSION_INFO VERSIONINFO VALUE "FileDescription", "GIMP Drawing Kit" VALUE "FileVersion", "@GTK_VERSION@.BUILDNUMBER" VALUE "InternalName", "libgdk-win32-@GTK_API_VERSION@-@LT_CURRENT_MINUS_AGE@" - VALUE "LegalCopyright", "Copyright © 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald. Modified by the GTK+ Team and others 1997-2001." + VALUE "LegalCopyright", "Copyright © 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald. Modified by the GTK+ Team and others 1997-2002." VALUE "OriginalFilename", "libgdk-win32-@GTK_API_VERSION@-@LT_CURRENT_MINUS_AGE@.dll" VALUE "ProductName", "GTK+" VALUE "ProductVersion", "@GTK_VERSION@"