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
        +----GInitiallyUnowned
              +----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 and  'GtkBuildable'.

_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
     'gtkContainerChildSetValist()'.  To obtain the value of a child
     property, use  'gtkContainerChildGetProperty',
     'gtkContainerChildGet' or 'gtkContainerChildGetValist()'. To emit
     notification about child property  changes, use
     'gtkWidgetChildNotify'.

_G_t_k_C_o_n_t_a_i_n_e_r _a_s _G_t_k_B_u_i_l_d_a_b_l_e:

     The GtkContainer implementation of the GtkBuildable interface 
     supports a <packing> element for children, which can contain
     multiple <property> elements that specify child properties for the
     child.

     _Child properties in UI definitions_ <object class="GtkVBox">
       <child>
         <object class="GtkLabel"/>
         <packing>
           <property name="pack-type">start</property>
         </packing>
       </child>
     </object>


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


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

          '_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:


     '_a_d_d(_c_o_n_t_a_i_n_e_r, _w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_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_h_e_c_k-_r_e_s_i_z_e(_c_o_n_t_a_i_n_e_r, _u_s_e_r._d_a_t_a)' _undocumented _

          '_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.


     '_r_e_m_o_v_e(_c_o_n_t_a_i_n_e_r, _w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_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.


     '_s_e_t-_f_o_c_u_s-_c_h_i_l_d(_c_o_n_t_a_i_n_e_r, _w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_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>

