Lerking/gtk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

we use window->need_resize from configure_event now, to indicate that the

Browse Source 
Wed Aug 18 09:20:10 1999  Tim Janik  <timj@gtk.org>

        * gtk/gtkwindow.c:
        we use window->need_resize from configure_event now, to indicate that
        the gtkwindow should keep its allocation (e.g. because the user resized
        the window through window manager handles). resize_count is now reliably
        used to figure whether we got the allocation we requested from the
        window manager.
        configure events get queued as resizes now, the real stuff (size
        computation and allocation) now only goes on in gtk_window_move_resize().
        GtkWindow's requisition now contains its *real* requisition (like all
        other widgets), *not* taking usize into account.
        geometry_info->last_{width|height} is now updated from set_hints() only
        so it always contains the last hints we set for the window manager.
        made some event handlers return TRUE instead of FALSE.
        the overall code should be much more straight forward now, and the
        significant code portions are accompanied by comments now.
        (gtk_window_set_hints):
        removed requisition argument and made it
        fetch the requisition through gtk_widget_get_child_requisition.
        we also don't move the gdkwindow here anymore, gtk_window_move_resize()
        does that now.
        (gtk_window_show):
        ensure that the widget is realized before calling
        gtk_container_check_resize() (and thus gtk_window_move_resize()), also
        ensure that we got properly size requested and allocated before
        realization.
        (gtk_window_configure_event):
        ignore plain window moves, or reallocate the widget tree through the
        resize queue otherwise.
        (gtk_window_move_resize):
        mostly rewrote this function to figure window manager hints more
        reliably, coalesce window moves and resizes to reduce configure events
        and do actuall size allocations.

Tue Aug 17 07:43:04 1999  Tim Janik  <timj@gtk.org>

        * gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
        that have a resize pending, because a redraw is already queued for them.

        * gdk/gdkevents.c (gdk_event_translate): give a debugging note when
        discarding configure events.

        * gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
        hack to clear resize_widgets.

        * gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
        for resize containers prior to size allocation. (this is also a bit
        ugly, but avoids side effects for stopped emissions and is thus more
        reliable).
        (gtk_widget_unparent): removed disconnect call for clear_resize_widgets.

        * gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
        function from gtk_tooltips_expose, as we connect to ::expose_event
        *and* ::draw now.

Tue Aug 17 07:43:04 1999  Tim Janik  <timj@gtk.org>

        * gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
        that have a resize pending, because a redraw is already queued for them.

        * gdk/gdkevents.c (gdk_event_translate): give a debugging note when
        discarding configure events.

        * gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
        hack to clear resize_widgets.

        * gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
        for resize containers prior to size allocation. (this is also a bit
        ugly, but avoids side effects for stopped emissions and is thus more
        reliable).
        (gtk_widget_unparent): removed disconnect call for clear_resize_widgets.

        * gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
        function from gtk_tooltips_expose, as we connect to ::expose_event
        *and* ::draw now.
This commit is contained in:
Tim Janik
1999-08-20 02:18:22 +00:00
committed by Tim Janik
parent 5568346aa2
commit f5891aa3bf
13 changed files with 683 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
ChangeLog
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

57
ChangeLog.pre-2-0
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

57
ChangeLog.pre-2-10
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

57
ChangeLog.pre-2-2
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

57
ChangeLog.pre-2-4
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

57
ChangeLog.pre-2-6
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

57
ChangeLog.pre-2-8
View File

@@ -1,3 +1,59 @@
Wed Aug 18 09:20:10 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c:
we use window->need_resize from configure_event now, to indicate that
the gtkwindow should keep its allocation (e.g. because the user resized
the window through window manager handles). resize_count is now reliably
used to figure whether we got the allocation we requested from the
window manager.
configure events get queued as resizes now, the real stuff (size
computation and allocation) now only goes on in gtk_window_move_resize().
GtkWindow's requisition now contains its *real* requisition (like all
other widgets), *not* taking usize into account.
geometry_info->last_{width|height} is now updated from set_hints() only
so it always contains the last hints we set for the window manager.
made some event handlers return TRUE instead of FALSE.
the overall code should be much more straight forward now, and the
significant code portions are accompanied by comments now.
(gtk_window_set_hints):
removed requisition argument and made it
fetch the requisition through gtk_widget_get_child_requisition.
we also don't move the gdkwindow here anymore, gtk_window_move_resize()
does that now.
(gtk_window_show):
ensure that the widget is realized before calling
gtk_container_check_resize() (and thus gtk_window_move_resize()), also
ensure that we got properly size requested and allocated before
realization.
(gtk_window_configure_event):
ignore plain window moves, or reallocate the widget tree through the
resize queue otherwise.
(gtk_window_move_resize):
mostly rewrote this function to figure window manager hints more
reliably, coalesce window moves and resizes to reduce configure events
and do actuall size allocations.
Tue Aug 17 07:43:04 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwidget.c (gtk_widget_event): discard expose events for widgets
that have a resize pending, because a redraw is already queued for them.
* gdk/gdkevents.c (gdk_event_translate): give a debugging note when
discarding configure events.
* gtk/gtkcontainer.c: removed ugly connect_to ::size_allocate signal
hack to clear resize_widgets.
* gtk/gtkwidget.c (gtk_widget_size_allocate): call clear_resize_widgets
for resize containers prior to size allocation. (this is also a bit
ugly, but avoids side effects for stopped emissions and is thus more
reliable).
(gtk_widget_unparent): removed disconnect call for clear_resize_widgets.
* gtk/gtktooltips.c (gtk_tooltips_paint_window): renamed this
function from gtk_tooltips_expose, as we connect to ::expose_event
*and* ::draw now.
1999-08-18 Federico Mena Quintero <federico@redhat.com>
* gtk/gtkselection.c (gtk_target_list_ref): Added missing sanity
@@ -181,7 +237,6 @@ Tue Jun 29 15:59:25 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LIBS): Look for libgmodule in the
right location.
>>>>>>> 1.1061.2.97
Mon Jun 28 09:29:52 1999 Tim Janik <timj@gtk.org>
* gtk/gtkwindow.c: add ::default_width and ::default_height arguments.

9
gdk/gdkevents.c
View File

@@ -1696,7 +1696,7 @@ gdk_event_translate (GdkEvent *event,
GDK_NOTE (EVENTS,
g_message ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d b-w: %d above: %ld ovr: %d",
g_message ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d b-w: %d above: %ld ovr: %d%s",
xevent->xconfigure.window,
xevent->xconfigure.x,
xevent->xconfigure.y,
@@ -1704,7 +1704,12 @@ gdk_event_translate (GdkEvent *event,
xevent->xconfigure.height,
xevent->xconfigure.border_width,
xevent->xconfigure.above,
xevent->xconfigure.override_redirect));
xevent->xconfigure.override_redirect,
!window
? " (discarding)"
: window_private->window_type == GDK_WINDOW_CHILD
? " (discarding child)"
: ""));
if (window &&
!window_private->destroyed &&
(window_private->extension_events != 0) &&

9
gdk/x11/gdkevents-x11.c
View File

@@ -1696,7 +1696,7 @@ gdk_event_translate (GdkEvent *event,
GDK_NOTE (EVENTS,
g_message ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d b-w: %d above: %ld ovr: %d",
g_message ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d b-w: %d above: %ld ovr: %d%s",
xevent->xconfigure.window,
xevent->xconfigure.x,
xevent->xconfigure.y,
@@ -1704,7 +1704,12 @@ gdk_event_translate (GdkEvent *event,
xevent->xconfigure.height,
xevent->xconfigure.border_width,
xevent->xconfigure.above,
xevent->xconfigure.override_redirect));
xevent->xconfigure.override_redirect,
!window
? " (discarding)"
: window_private->window_type == GDK_WINDOW_CHILD
? " (discarding child)"
: ""));
if (window &&
!window_private->destroyed &&
(window_private->extension_events != 0) &&

23
gtk/gtkcontainer.c
View File

@@ -735,11 +735,6 @@ gtk_container_clear_resize_widgets (GtkContainer *container)
node = container->resize_widgets;
if (node)
gtk_signal_disconnect_by_func (GTK_OBJECT (container),
GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
NULL);
while (node)
{
GtkWidget *widget = node->data;
@@ -860,29 +855,19 @@ gtk_container_queue_resize (GtkContainer *container)
}
GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
if (!resize_container->resize_widgets)
gtk_signal_connect (GTK_OBJECT (resize_container),
"size_allocate",
GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
NULL);
resize_container->resize_widgets =
g_slist_prepend (resize_container->resize_widgets, container);
break;
case GTK_RESIZE_IMMEDIATE:
GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
if (!resize_container->resize_widgets)
gtk_signal_connect (GTK_OBJECT (resize_container),
"size_allocate",
GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
NULL);
resize_container->resize_widgets =
g_slist_prepend (resize_container->resize_widgets, container);
gtk_container_check_resize (resize_container);
break;
case GTK_RESIZE_PARENT:
/* Ignore */
/* Ignore, should not be reached */
break;
}
}
@@ -890,7 +875,7 @@ gtk_container_queue_resize (GtkContainer *container)
{
/* We need to let hidden toplevels know that something
* changed while they where hidden. For other resize containers,
* they will get resized when they are shown.
* they will get resized after they are shown.
*/
if (GTK_WIDGET_TOPLEVEL (resize_container))
gtk_container_check_resize (resize_container);
@@ -1006,10 +991,6 @@ gtk_container_resize_children (GtkContainer *container)
* is insufficient, since we don't need to reallocate below that.
*/
resize_widgets = container->resize_widgets;
if (resize_widgets)
gtk_signal_disconnect_by_func (GTK_OBJECT (container),
GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
NULL);
container->resize_widgets = NULL;
for (node = resize_widgets; node; node = node->next)
{

11
gtk/gtktooltips.c
View File

@@ -51,8 +51,7 @@ static void gtk_tooltips_widget_remove (GtkWidget *widget,
static void gtk_tooltips_set_active_widget (GtkTooltips *tooltips,
GtkWidget *widget);
static gint gtk_tooltips_timeout (gpointer data);
static gint gtk_tooltips_expose (GtkTooltips *tooltips,
GdkEventExpose *event);
static gint gtk_tooltips_paint_window (GtkTooltips *tooltips);
static void gtk_tooltips_draw_tips (GtkTooltips *tooltips);
@@ -190,7 +189,11 @@ gtk_tooltips_force_window (GtkTooltips *tooltips)
gtk_widget_set_name (tooltips->tip_window, "gtk-tooltips");
gtk_signal_connect_object (GTK_OBJECT (tooltips->tip_window),
"expose_event",
GTK_SIGNAL_FUNC (gtk_tooltips_expose),
GTK_SIGNAL_FUNC (gtk_tooltips_paint_window),
GTK_OBJECT (tooltips));
gtk_signal_connect_object (GTK_OBJECT (tooltips->tip_window),
"draw",
GTK_SIGNAL_FUNC (gtk_tooltips_paint_window),
GTK_OBJECT (tooltips));
gtk_signal_connect (GTK_OBJECT (tooltips->tip_window),
@@ -400,7 +403,7 @@ gtk_tooltips_set_colors (GtkTooltips *tooltips,
}
static gint
gtk_tooltips_expose (GtkTooltips *tooltips, GdkEventExpose *event)
gtk_tooltips_paint_window (GtkTooltips *tooltips)
{
GtkStyle *style;
gint y, baseline_skip, gap;

25
gtk/gtkwidget.c
View File

@@ -1338,17 +1338,7 @@ gtk_widget_unparent (GtkWidget *widget)
if (prev)
prev->next = slist;
else
{
/* it is really messy to have this signal disconnection
* in gtkwidget.c, the resize_widgets invariants should
* all be taken care off by gtkcontainer.c exclusively.
*/
if (!slist)
gtk_signal_disconnect_by_func (GTK_OBJECT (toplevel),
GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
NULL);
GTK_CONTAINER (toplevel)->resize_widgets = slist;
}
GTK_CONTAINER (toplevel)->resize_widgets = slist;
g_slist_free_1 (last);
}
@@ -2387,8 +2377,8 @@ gtk_widget_size_request (GtkWidget *widget,
*****************************************/
void
gtk_widget_get_child_requisition (GtkWidget *widget,
GtkRequisition *requisition)
gtk_widget_get_child_requisition (GtkWidget *widget,
GtkRequisition *requisition)
{
GtkWidgetAuxInfo *aux_info;
@@ -2469,6 +2459,9 @@ gtk_widget_size_allocate (GtkWidget *widget,
needs_draw = TRUE;
}
if (GTK_IS_RESIZE_CONTAINER (widget))
gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_ALLOCATE], &real_allocation);
if (needs_draw)
@@ -2784,8 +2777,11 @@ gtk_widget_event (GtkWidget *widget,
break;
case GDK_EXPOSE:
/* there is no sense in providing a widget with bogus expose events.
* also we make the optimization to discard expose events for widgets
* that have a resize pending, because a redraw is already queued for
* them.
*/
if (!event->any.window)
if (!event->any.window || GTK_WIDGET_RESIZE_NEEDED (widget))
{
gtk_widget_unref (widget);
return TRUE;
@@ -3720,6 +3716,7 @@ gtk_widget_set_uposition (GtkWidget *widget,
if (GTK_WIDGET_REALIZED (widget) && GTK_IS_WINDOW (widget) &&
(aux_info->x != -1) && (aux_info->y != -1))
{
/* keep this in sync with gtk_window_move_resize() */
gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
gdk_window_move (widget->window, aux_info->x, aux_info->y);
}

474
gtk/gtkwindow.c
View File

@@ -103,8 +103,7 @@ static void gtk_window_check_resize (GtkContainer *container);
static void gtk_window_real_set_focus (GtkWindow *window,
GtkWidget *focus);
static void gtk_window_move_resize (GtkWindow *window);
static void gtk_window_set_hints (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_window_set_hints (GtkWidget *widget);
static void gtk_window_read_rcfiles (GtkWidget *widget,
GdkEventClient *event);
@@ -225,6 +224,8 @@ gtk_window_init (GtkWindow *window)
gtk_container_set_resize_mode (GTK_CONTAINER (window), GTK_RESIZE_QUEUE);
GTK_CONTAINER (window)->need_resize = TRUE;
window->title = NULL;
window->wmclass_name = g_strdup (g_get_prgname ());
window->wmclass_class = g_strdup (gdk_progclass);
@@ -262,15 +263,15 @@ gtk_window_set_arg (GtkObject *object,
break;
case ARG_AUTO_SHRINK:
window->auto_shrink = (GTK_VALUE_BOOL (*arg) != FALSE);
gtk_window_set_hints (GTK_WIDGET (window), &GTK_WIDGET (window)->requisition);
gtk_window_set_hints (GTK_WIDGET (window));
break;
case ARG_ALLOW_SHRINK:
window->allow_shrink = (GTK_VALUE_BOOL (*arg) != FALSE);
gtk_window_set_hints (GTK_WIDGET (window), &GTK_WIDGET (window)->requisition);
gtk_window_set_hints (GTK_WIDGET (window));
break;
case ARG_ALLOW_GROW:
window->allow_grow = (GTK_VALUE_BOOL (*arg) != FALSE);
gtk_window_set_hints (GTK_WIDGET (window), &GTK_WIDGET (window)->requisition);
gtk_window_set_hints (GTK_WIDGET (window));
break;
case ARG_MODAL:
gtk_window_set_modal (window, GTK_VALUE_BOOL (*arg));
@@ -447,7 +448,7 @@ gtk_window_set_policy (GtkWindow *window,
window->allow_grow = (allow_grow != FALSE);
window->auto_shrink = (auto_shrink != FALSE);
gtk_window_set_hints (GTK_WIDGET (window), &GTK_WIDGET (window)->requisition);
gtk_window_set_hints (GTK_WIDGET (window));
}
void
@@ -792,7 +793,26 @@ gtk_window_show (GtkWidget *widget)
g_return_if_fail (GTK_IS_WINDOW (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
if (!GTK_WIDGET_REALIZED (widget))
{
GtkRequisition requisition;
GtkAllocation allocation = { 0, 0, 200, 200 };
gtk_widget_size_request (widget, &requisition);
if (requisition.width || requisition.height)
{
/* non-empty window */
allocation.width = requisition.width;
allocation.height = requisition.height;
}
gtk_widget_size_allocate (widget, &allocation);
gtk_widget_realize (widget);
}
gtk_container_check_resize (GTK_CONTAINER (widget));
gtk_widget_map (widget);
if (GTK_WINDOW (widget)->modal)
@@ -833,7 +853,7 @@ gtk_window_map (GtkWidget *widget)
!GTK_WIDGET_MAPPED (window->bin.child))
gtk_widget_map (window->bin.child);
gtk_window_set_hints (widget, &widget->requisition);
gtk_window_set_hints (widget);
gdk_window_show (widget->window);
}
@@ -850,6 +870,8 @@ gtk_window_unmap (GtkWidget *widget)
window = GTK_WINDOW (widget);
window->use_uposition = TRUE;
window->resize_count = 0;
window->handling_resize = FALSE;
}
static void
@@ -974,8 +996,6 @@ gtk_window_configure_event (GtkWidget *widget,
GdkEventConfigure *event)
{
GtkWindow *window;
GtkAllocation allocation;
gboolean need_expose = FALSE;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
@@ -983,59 +1003,43 @@ gtk_window_configure_event (GtkWidget *widget,
window = GTK_WINDOW (widget);
/* If the window was merely moved, do nothing */
if ((widget->allocation.width == event->width) &&
(widget->allocation.height == event->height))
/* we got a configure event specifying the new window size and position,
* in principle we have to distinguish 4 cases here:
* 1) the size didn't change and resize_count == 0
* -> the window was merely moved (sometimes not even that)
* 2) the size didn't change and resize_count > 0
* -> we requested a new size, but didn't get it
* 3) the size changed and resize_count > 0
* -> we asked for a new size and we got one
* 4) the size changed and resize_count == 0
* -> we got resized from outside the toolkit, and have to
* accept that size since we don't want to fight neither the
* window manager nor the user
* in the three latter cases we have to reallocate the widget tree,
* which happens in gtk_window_move_resize(), so we set a flag for
* that function and assign the new size. if resize_count > 1,
* we simply do nothing and wait for more configure events.
*/
if (window->resize_count > 0 ||
widget->allocation.width != event->width ||
widget->allocation.height != event->height)
{
if (window->resize_count == 0) /* The window was merely moved */
return FALSE;
else
if (window->resize_count > 0)
window->resize_count -= 1;
if (window->resize_count == 0)
{
/* We asked for a new size, which was rejected, so the
* WM sent us a synthetic configure event. We won't
* get the expose event we would normally get (since
* we have ForgetGravity), so we need to fake it.
*/
need_expose = TRUE;
window->handling_resize = TRUE;
widget->allocation.width = event->width;
widget->allocation.height = event->height;
gtk_widget_queue_resize (widget);
}
}
window->handling_resize = TRUE;
allocation.x = 0;
allocation.y = 0;
allocation.width = event->width;
allocation.height = event->height;
gtk_widget_size_allocate (widget, &allocation);
if (window->bin.child &&
GTK_WIDGET_VISIBLE (window->bin.child) &&
!GTK_WIDGET_MAPPED (window->bin.child))
gtk_widget_map (window->bin.child);
if (window->resize_count > 0)
window->resize_count -= 1;
if (need_expose)
{
GdkEvent temp_event;
temp_event.type = GDK_EXPOSE;
temp_event.expose.window = widget->window;
temp_event.expose.send_event = TRUE;
temp_event.expose.area.x = 0;
temp_event.expose.area.y = 0;
temp_event.expose.area.width = event->width;
temp_event.expose.area.height = event->height;
temp_event.expose.count = 0;
gtk_widget_event (widget, &temp_event);
}
window->handling_resize = FALSE;
return FALSE;
return TRUE;
}
static gint
@@ -1317,21 +1321,17 @@ gtk_window_check_resize (GtkContainer *container)
g_return_if_fail (GTK_IS_WINDOW (container));
window = GTK_WINDOW (container);
if (!window->handling_resize)
{
if (GTK_WIDGET_VISIBLE (container))
gtk_window_move_resize (window);
else
GTK_CONTAINER (window)->need_resize = TRUE;
}
if (GTK_WIDGET_VISIBLE (container))
gtk_window_move_resize (window);
else
GTK_CONTAINER (window)->need_resize = TRUE;
}
/* FIXME: we leave container->resize_widgets set under some
circumstances ? */
static void
gtk_window_move_resize (GtkWindow *window)
{
GtkWidget *widget;
GtkWidget *widget;
GtkWindowGeometryInfo *info;
GtkRequisition requisition;
GtkContainer *container;
@@ -1339,66 +1339,43 @@ gtk_window_move_resize (GtkWindow *window)
gint width, height;
gint new_width, new_height;
gint min_width, min_height;
gint screen_width;
gint screen_height;
gboolean needed_resize;
gboolean size_changed;
gboolean requisition_changed;
gboolean hints_changed = FALSE;
g_return_if_fail (window != NULL);
g_return_if_fail (GTK_IS_WINDOW (window));
widget = GTK_WIDGET (window);
container = GTK_CONTAINER (widget);
info = gtk_window_get_geometry_info (window, FALSE);
/* Remember old size, to know if we have to reset hints */
if (info && (info->last_width > 0))
width = info->last_width;
else
width = widget->requisition.width;
if (info && (info->last_height > 0))
height = info->last_height;
else
height = widget->requisition.height;
size_changed = FALSE;
/* get new requisition and figure whether it differs from current
*/
gtk_widget_get_child_requisition (widget, &requisition);
width = requisition.width;
height = requisition.height;
gtk_widget_size_request (widget, &requisition);
requisition_changed = requisition.width != width || requisition.height != height;
size_changed |= requisition.width != widget->requisition.width;
size_changed |= requisition.height != widget->requisition.height;
widget->requisition = requisition;
/* Figure out the new desired size */
if (info && info->width > 0)
/* figure out the new desired size, and
* check whether we need to reset hints
*/
new_width = requisition.width;
new_height = requisition.height;
if (!new_width && !new_height)
{
size_changed |= width != info->last_width;
info->last_width = width;
new_width = info->width;
/* empty window */
new_width = 200;
new_height = 200;
}
else
if (info)
{
size_changed |= width != widget->requisition.width;
new_width = widget->requisition.width;
}
if (info && info->height > 0)
{
size_changed |= height != info->last_height;
info->last_height = height;
new_height = info->height;
}
else
{
size_changed |= height != widget->requisition.height;
new_height = widget->requisition.height;
new_width = info->width > 0 ? info->width : new_width;
new_height = info->height > 0 ? info->height : new_height;
hints_changed |= new_width != info->last_width || new_height != info->last_height;
}
/* Figure out the new minimum size */
if (info && (info->mask & (GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE)))
{
if (info->mask && GDK_HINT_MIN_SIZE)
@@ -1420,64 +1397,15 @@ gtk_window_move_resize (GtkWindow *window)
}
else
{
min_width = widget->requisition.width;
min_height = widget->requisition.height;
min_width = MIN (widget->requisition.width, requisition.width);
min_height = MIN (widget->requisition.height, requisition.height);
}
if (size_changed)
{
gboolean saved_use_upos;
saved_use_upos = window->use_uposition;
gtk_window_set_hints (widget, &widget->requisition);
window->use_uposition = saved_use_upos;
}
x = -1;
y = -1;
if (window->use_uposition)
switch (window->position)
{
case GTK_WIN_POS_CENTER:
x = (gdk_screen_width () - new_width) / 2;
y = (gdk_screen_height () - new_height) / 2;
gtk_widget_set_uposition (widget, x, y);
break;
case GTK_WIN_POS_MOUSE:
gdk_window_get_pointer (NULL, &x, &y, NULL);
x -= new_width / 2;
y -= new_height / 2;
screen_width = gdk_screen_width ();
screen_height = gdk_screen_height ();
if (x < 0)
x = 0;
else if (x > (screen_width - new_width))
x = screen_width - new_width;
if (y < 0)
y = 0;
else if (y > (screen_height - new_height))
y = screen_height - new_height;
gtk_widget_set_uposition (widget, x, y);
break;
}
/* Now, do the resizing */
needed_resize = container->need_resize;
container->need_resize = FALSE;
if ((new_width == 0) || (new_height == 0))
{
new_width = 200;
new_height = 200;
}
if (hints_changed)
gtk_window_set_hints (widget);
/* if we are not yet realized, only size_allocate the widget tree
*/
if (!GTK_WIDGET_REALIZED (window))
{
GtkAllocation allocation;
@@ -1491,29 +1419,149 @@ gtk_window_move_resize (GtkWindow *window)
return;
}
gdk_window_get_geometry (widget->window, NULL, NULL, &width, &height, NULL);
/* As an optimization, we don't try to get a new size from the
* window manager if we asked for the same size last time and
* didn't get it */
if (size_changed &&
(((window->auto_shrink &&
((width != new_width) ||
(height != new_height)))) ||
((width < min_width) ||
(height < min_height))))
/* calculate window position if neccessary
*/
x = -1;
y = -1;
switch (window->position)
{
case GTK_WIN_POS_CENTER:
if (window->use_uposition || requisition_changed)
{
gint screen_width = gdk_screen_width ();
gint screen_height = gdk_screen_height ();
x = (screen_width - new_width) / 2;
y = (screen_height - new_height) / 2;
}
break;
case GTK_WIN_POS_MOUSE:
if (window->use_uposition)
{
gint screen_width = gdk_screen_width ();
gint screen_height = gdk_screen_height ();
gdk_window_get_pointer (NULL, &x, &y, NULL);
x -= new_width / 2;
y -= new_height / 2;
x = CLAMP (x, 0, screen_width - new_width);
y = CLAMP (y, 0, screen_height - new_height);
}
break;
default:
if (window->use_uposition)
{
GtkWidgetAuxInfo *aux_info;
aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
if (aux_info &&
aux_info->x != -1 && aux_info->y != -1 &&
aux_info->x != -2 && aux_info->y != -2)
{
x = aux_info->x;
y = aux_info->y;
}
}
break;
}
if (x != -1 && y != -1)
{
GtkWidgetAuxInfo *aux_info;
/* we handle neccessary window positioning by hand here,
* so we can coalesce the window movement with possible
* resizes to get only one configure event.
* keep this in sync with gtk_widget_set_uposition().
*/
gtk_widget_set_uposition (widget, -1, -1); /* ensure we have aux_info */
aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
aux_info->x = x;
aux_info->y = y;
gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
gdk_window_move (widget->window, aux_info->x, aux_info->y);
window->use_uposition = FALSE;
}
if (x != -1 && y != -1)
{
gint geo_x, geo_y;
gdk_window_get_geometry (widget->window, &geo_x, &geo_y, &width, &height, NULL);
if (x == geo_x && y == geo_y)
{
x = -1;
y = -1;
}
}
else
gdk_window_get_geometry (widget->window, NULL, NULL, &width, &height, NULL);
/* away into the actuall resizing
*/
if (window->handling_resize)
{
GtkAllocation allocation;
/* we just have to react to a resize by the window manager
* or the user, so simply size_allocate the widget tree.
* see gtk_window_configure_event() for this.
*/
window->handling_resize = FALSE;
new_width = widget->allocation.width;
new_height = widget->allocation.height;
allocation.x = 0;
allocation.y = 0;
allocation.width = new_width;
allocation.height = new_height;
gtk_widget_size_allocate (widget, &allocation);
gtk_widget_queue_draw (widget);
}
else if (container->need_resize)
{
/* we need a full layout, since visibility has changed and
* we didn't keep track of what changed.
*/
container->need_resize = FALSE;
if (x != -1 && y != -1)
gdk_window_move_resize (widget->window, x, y,
new_width,
new_height);
else
gdk_window_resize (widget->window,
new_width,
new_height);
window->resize_count += 1;
/* we are now awaiting the new configure event, which will cause a
* resize. as an optimization, we queue the resize already here so
* intermediate expose events get discarded.
*/
gtk_widget_queue_resize (widget);
}
else if (requisition_changed &&
((window->auto_shrink && (width != new_width || height != new_height)) ||
(width < min_width || height < min_height)))
{
/* As an optimization, we don't try to get a new size from the
* window manager if we asked for the same size last time and
* didn't get it.
* to achive this, we record GdkWindow resizes in resize_count and
* if we didn't get it, we'll catch that case in the
* gtk_window_configure_event() handler.
*/
if (!window->auto_shrink)
{
new_width = MAX(width, min_width);
new_height = MAX(height, min_height);
new_width = MAX (width, min_width);
new_height = MAX (height, min_height);
}
if ((x != -1) && (y != -1))
if (x != -1 && y != -1)
gdk_window_move_resize (widget->window, x, y,
new_width,
new_height);
@@ -1521,28 +1569,11 @@ gtk_window_move_resize (GtkWindow *window)
gdk_window_resize (widget->window,
new_width,
new_height);
}
else if (needed_resize)
{
/* The windows contents changed size while it was not
* visible, so reallocate everything, since we didn't
* keep track of what changed
*/
GtkAllocation allocation;
allocation.x = 0;
allocation.y = 0;
allocation.width = new_width;
allocation.height = new_height;
gtk_widget_size_allocate (widget, &allocation);
gdk_window_resize (widget->window,
new_width,
new_height);
window->resize_count += 1;
}
else
{
if ((x != -1) && (y != -1))
if (x != -1 && y != -1)
gdk_window_move (widget->window, x, y);
gtk_container_resize_children (GTK_CONTAINER (window));
@@ -1618,12 +1649,10 @@ gtk_window_real_set_focus (GtkWindow *window,
}
static void
gtk_window_set_hints (GtkWidget *widget,
GtkRequisition *requisition)
gtk_window_set_hints (GtkWidget *widget)
{
GtkWindow *window;
GtkWidgetAuxInfo *aux_info;
GtkWindowGeometryInfo *geometry_info;
GdkGeometry new_geometry;
gint flags;
gint ux, uy;
@@ -1632,12 +1661,15 @@ gtk_window_set_hints (GtkWidget *widget,
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WINDOW (widget));
g_return_if_fail (requisition != NULL);
if (GTK_WIDGET_REALIZED (widget))
window = GTK_WINDOW (widget);
if (GTK_WIDGET_REALIZED (window))
{
window = GTK_WINDOW (widget);
GtkWindowGeometryInfo *geometry_info;
GtkRequisition requisition;
gtk_widget_get_child_requisition (widget, &requisition);
geometry_info = gtk_window_get_geometry_info (GTK_WINDOW (widget), FALSE);
if (geometry_info)
@@ -1647,8 +1679,8 @@ gtk_window_set_hints (GtkWidget *widget,
if (geometry_info->widget)
{
extra_width = requisition->width - geometry_info->widget->requisition.width;
extra_height = requisition->height - geometry_info->widget->requisition.height;
extra_width = widget->requisition.width - geometry_info->widget->requisition.width;
extra_height = widget->requisition.height - geometry_info->widget->requisition.height;
}
}
else
@@ -1689,8 +1721,8 @@ gtk_window_set_hints (GtkWidget *widget,
{
flags |= GDK_HINT_MIN_SIZE;
new_geometry.min_width = requisition->width;
new_geometry.min_height = requisition->height;
new_geometry.min_width = requisition.width;
new_geometry.min_height = requisition.height;
}
if (flags & GDK_HINT_MAX_SIZE)
@@ -1702,16 +1734,24 @@ gtk_window_set_hints (GtkWidget *widget,
{
flags |= GDK_HINT_MAX_SIZE;
new_geometry.max_width = requisition->width;
new_geometry.max_height = requisition->height;
new_geometry.max_width = requisition.width;
new_geometry.max_height = requisition.height;
}
gdk_window_set_geometry_hints (widget->window, &new_geometry, flags);
if (window->use_uposition && (flags & GDK_HINT_POS))
if (geometry_info)
{
window->use_uposition = FALSE;
gdk_window_move (widget->window, ux, uy);
if (flags & GDK_HINT_BASE_SIZE)
{
geometry_info->last_width = new_geometry.base_width;
geometry_info->last_height = new_geometry.base_height;
}
else
{
geometry_info->last_width = -1;
geometry_info->last_height = -1;
}
}
}
}
@@ -1736,9 +1776,9 @@ gtk_window_expose (GtkWidget *widget,
gtk_window_paint (widget, &event->area);
if (GTK_WIDGET_CLASS (parent_class)->expose_event)
return (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
return FALSE;
return TRUE;
}
static void