gtkWindowSetPolicy           package:RGtk2           R Documentation

_g_t_k_W_i_n_d_o_w_S_e_t_P_o_l_i_c_y

_D_e_s_c_r_i_p_t_i_o_n:

     Changes how a toplevel window deals with its size request and user
     resize attempts. There are really only two reasonable ways to call
     this function:

        1.  'gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE,
           FALSE)'  means that the window is user-resizable.

        2.  '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.*

_U_s_a_g_e:

     gtkWindowSetPolicy(object, allow.shrink, allow.grow, auto.shrink)

_A_r_g_u_m_e_n_t_s:

'object': ['GtkWindow'] the window

'allow.shrink': [integer] whether the user can shrink the window below
          its size request

'allow.grow': [integer] whether the user can grow the window larger
          than its size request

'auto.shrink': [integer] whether the window automatically snaps back to
          its size request  if it's larger

_D_e_t_a_i_l_s:

     The basic ugly truth of this function is that it should be simply:
     ' 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.

_A_u_t_h_o_r(_s):

     Derived by RGtkGen from GTK+ documentation

