GtkContainer              package:RGtk2              R Documentation

_G_t_k_C_o_n_t_a_i_n_e_r

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

     Base class for widgets which contain other widgets

_M_e_t_h_o_d_s _a_n_d _F_u_n_c_t_i_o_n_s:

     'gtkContainerAdd(object, widget)'
      'gtkContainerRemove(object, widget)'
      'gtkContainerAddWithProperties(object, widget, ...)'
      'gtkContainerGetResizeMode(object)'
      'gtkContainerSetResizeMode(object, resize.mode)'
      'gtkContainerCheckResize(object)'
      'gtkContainerForeach(object, callback, callback.data = NULL)'
      'gtkContainerForeachFull(object, callback, callback.data = NULL)'
      'gtkContainerGetChildren(object)'
      'gtkContainerSetReallocateRedraws(object, needs.redraws)'
      'gtkContainerSetFocusChild(object, child)'
      'gtkContainerGetFocusVadjustment(object)'
      'gtkContainerSetFocusVadjustment(object, adjustment)'
      'gtkContainerGetFocusHadjustment(object)'
      'gtkContainerSetFocusHadjustment(object, adjustment)'
      'gtkContainerResizeChildren(object)'
      'gtkContainerChildType(object)'
      'gtkContainerChildGet(object, child, ...)'
      'gtkContainerChildSet(object, child, ...)'
      'gtkContainerChildGetProperty(object, child, property.name)'
      'gtkContainerChildSetProperty(object, child, property.name,
     value)'
      'gtkContainerForall(object, callback, callback.data = NULL)'
      'gtkContainerGetBorderWidth(object)'
      'gtkContainerSetBorderWidth(object, border.width)'
      'gtkContainerPropagateExpose(object, child, event)'
      'gtkContainerGetFocusChain(object)'
      'gtkContainerSetFocusChain(object, focusable.widgets)'
      'gtkContainerUnsetFocusChain(object)'
      'gtkContainerClassFindChildProperty(cclass, property.name)'
      'gtkContainerClassInstallChildProperty(cclass, property.id,
     pspec)'
      'gtkContainerClassListChildProperties(cclass)'

_H_i_e_r_a_r_c_h_y:

     GObject
        +----GtkObject
              +----GtkWidget
                    +----GtkContainer
                          +----GtkBin
                          +----GtkBox
                          +----GtkCList
                          +----GtkFixed
                          +----GtkPaned
                          +----GtkIconView
                          +----GtkLayout
                          +----GtkList
                          +----GtkMenuShell
                          +----GtkNotebook
                          +----GtkSocket
                          +----GtkTable
                          +----GtkTextView
                          +----GtkToolbar
                          +----GtkTree
                          +----GtkTreeView 

_I_n_t_e_r_f_a_c_e_s:

     GtkContainer implements AtkImplementorIface.

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

     A GTK+ user interface is constructed by nesting widgets inside
     widgets. Container widgets are the inner nodes in the resulting
     tree of widgets: they contain other widgets. So, for example, you
     might have a  'GtkWindow' containing a 'GtkFrame' containing a
     GtkLabel. If you wanted an image instead of a textual label 
     inside the frame, you might replace the 'GtkLabel' widget with a
     'GtkImage' widget.

     There are two major kinds of container widgets in GTK+. Both are
     subclasses of the abstract 'GtkContainer'  base class.

     The first type of container widget has a single child widget and
     derives from 'GtkBin'. These containers are decorators, which add
     some kind of functionality to the child. For example,  a
     'GtkButton' makes its child into a clickable button; a 'GtkFrame'
     draws a frame around its child and  a 'GtkWindow' places its child
     widget inside a top-level window.

     The second type of container can have more than one child; its
     purpose is to manage  layout. This means that these containers
     assign sizes and positions to their children.  For example, a
     'GtkHBox' arranges its children in a horizontal row, and a
     'GtkTable' arranges the widgets it contains in a two-dimensional
     grid. 

     To fulfill its task, a layout container must negotiate the size
     requirements with its parent and its children. This negotiation is
     carried out in two phases, size requisition and  size allocation.

_S_i_z_e _R_e_q_u_i_s_i_t_i_o_n:

     The size requisition of a widget is it's desired width and height.
     This is represented by a 'GtkRequisition'.

     How a widget determines its desired size depends on the widget. A
     'GtkLabel', for example, requests enough space  to display all its
     text. Container widgets generally base their size request on the
     requisitions of their  children.  

     The size requisition phase of the widget layout process operates
     top-down. It starts at a top-level widget, typically a
     'GtkWindow'. The top-level widget asks its child for its size
     requisition by calling 'gtkWidgetSizeRequest'. To determine its
     requisition, the child asks its own children for their
     requisitions  and so on. Finally, the top-level widget will get a
     requisition back from its child.

_S_i_z_e _A_l_l_o_c_a_t_i_o_n:

     When the top-level widget has determined how much space its child
     would like to have, the second phase of the size negotiation, size
     allocation, begins. Depending on its configuration (see
     'gtkWindowSetResizable'), the  top-level widget may be able to
     expand in order to satisfy the size request or it may have to
     ignore the size  request and keep its fixed size. It then tells
     its child widget how much space it gets by calling 
     'gtkWidgetSizeAllocate'. The child widget divides the space among
     its children and tells each child how much  space it got, and so
     on. Under normal circumstances, a 'GtkWindow' will always give its
     child the amount of space the child requested.

     A child's size allocation is represented by a 'GtkAllocation'.
     This struct contains not only a width and height,  but also a
     position (i.e. X and Y coordinates), so that containers can tell
     their children not only how much space they have gotten, but also
     where they are positioned inside the space available to the
     container. 

     Widgets are required to honor the size allocation they receive; a
     size request is only a request, and widgets must be able to cope
     with any size.

_C_h_i_l_d _p_r_o_p_e_r_t_i_e_s:

     'GtkContainer' introduces child  properties - these are object
     properties that are not specific to either the container or the
     contained widget, but rather to their relation. Typical examples
     of child properties are the position or pack-type of a widget
     which is contained in a 'GtkBox'.   Use
     'gtkContainerClassInstallChildProperty' to install child
     properties  for a container class and
     'gtkContainerClassFindChildProperty' or
     'gtkContainerClassListChildProperties' to get information about
     existing child properties.

     To set the value of a child property, use
     'gtkContainerChildSetProperty',  'gtkContainerChildSet' or
     'gtk\Container\Child\Set\Valist()'.  To obtain the value of a
     child property, use  'gtkContainerChildGetProperty',
     'gtkContainerChildGet' or 'gtk\Container\Child\Get\Valist()'. To
     emit notification about child property  changes, use
     'gtkWidgetChildNotify'.

_S_t_r_u_c_t_u_r_e_s:

          '_f_o_c_u_s_C_h_i_l_d' ['GtkWidget'] 

          '_b_o_r_d_e_r_W_i_d_t_h' [numeric] 

          '_n_e_e_d_R_e_s_i_z_e' [numeric] 

          '_r_e_s_i_z_e_M_o_d_e' [numeric] 

          '_r_e_a_l_l_o_c_a_t_e_R_e_d_r_a_w_s' [numeric] 

          '_h_a_s_F_o_c_u_s_C_h_a_i_n' [numeric] 

_S_i_g_n_a_l_s:

          '_c_o_n_t_a_i_n_e_r' ['GtkContainer'] the object which received the
               signal.

          '_w_i_d_g_e_t' ['GtkWidget'] 

          '_u_s_e_r._d_a_t_a' [R object] user data set when the signal handler
               was connected.


          '_c_o_n_t_a_i_n_e_r' ['GtkContainer'] the object which received the
               signal.

          '_u_s_e_r._d_a_t_a' [R object] user data set when the signal handler
               was connected.


          '_c_o_n_t_a_i_n_e_r' ['GtkContainer'] the object which received the
               signal.

          '_w_i_d_g_e_t' ['GtkWidget'] 

          '_u_s_e_r._d_a_t_a' [R object] user data set when the signal handler
               was connected.


          '_c_o_n_t_a_i_n_e_r' ['GtkContainer'] the object which received the
               signal.

          '_w_i_d_g_e_t' ['GtkWidget'] 

          '_u_s_e_r._d_a_t_a' [R object] user data set when the signal handler
               was connected.


_P_r_o_p_e_r_t_i_e_s:

     '_b_o_r_d_e_r-_w_i_d_t_h' [_n_u_m_e_r_i_c : _R_e_a_d / _W_r_i_t_e] The width of the empty
          border outside the containers children.  Allowed values: <=
          G_MAXINT  Default value: 0


     '_c_h_i_l_d' ['_G_t_k_W_i_d_g_e_t' : _W_r_i_t_e] Can be used to add a new child to
          the container.


     '_r_e_s_i_z_e-_m_o_d_e' ['_G_t_k_R_e_s_i_z_e_M_o_d_e' : _R_e_a_d / _W_r_i_t_e] Specify how resize
          events are handled.  Default value: GTK_RESIZE_PARENT


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

     Derived by RGtkGen from GTK+ documentation

_R_e_f_e_r_e_n_c_e_s:

     <URL:
     http://developer.gnome.org/doc/API/2.0/gtk/GtkContainer.html>

