gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE)
means that the window is user-resizable.
gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, TRUE)
means that the window's size is program-controlled, and should simply match
the current size request of the window's children.
The first policy is the default, that is, by default windows are designed to
be resized by users.
WARNING: gtk_window_set_policy
is deprecated and should not be used in newly-written code. Use gtkWindowSetResizable
instead.
gtkWindowSetPolicy(object, allow.shrink, allow.grow, auto.shrink)
object
allow.shrink
allow.grow
auto.shrink
void gtk_window_set_resizable (GtkWindow* window, gboolean setting);
...which is why GTK+ 2.0 introduces gtkWindowSetResizable
, which you
should use instead of gtkWindowSetPolicy
.
If set to TRUE
, the allow.grow
parameter allows the user to expand the window
beyond the size request of its child widgets. If allow.grow
is TRUE
, be sure to
check that your child widgets work properly as the window is resized.
A toplevel window will always change size to ensure its child widgets receive
their requested size. This means that if you add child widgets, the toplevel
window will expand to contain them. However, normally the toplevel will not
shrink to fit the size request of its children if it's too large; the
auto.shrink
parameter causes the window to shrink when child widgets have too
much space. auto.shrink
is normally used with the second of the two window
policies mentioned above. That is, set auto.shrink
to TRUE
if you want the
window to have a fixed, always-optimal size determined by your program.
Note that auto.shrink
doesn't do anything if allow.shrink
and allow.grow
are
both set to FALSE
.
Neither of the two suggested window policies set the allow.shrink
parameter to
TRUE
. If allow.shrink
is TRUE
, the user can shrink the window so that its
children do not receive their full size request; this is basically a bad thing,
because most widgets will look wrong if this happens. Furthermore GTK+ has a
tendency to re-expand the window if size is recalculated for any reason. The
upshot is that allow.shrink
should always be set to FALSE
.
Sometimes when you think you want to use allow.shrink
, the real problem is that
some specific child widget is requesting too much space, so the user can't
shrink the window sufficiently. Perhaps you are calling gtkWidgetSetSizeRequest
on a child widget, and forcing its size request to be too large. Instead of
setting the child's usize, consider using gtkWindowSetDefaultSize
so that
the child gets a larger allocation than it requests.