RGtkDataFrame             package:RGtk2             R Documentation

_T_h_e _R_G_t_k_D_a_t_a_F_r_a_m_e _m_o_d_e_l

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

     A 'GtkTreeModel' implementation backed by an R data frame

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

     rGtkDataFrame(frame = data.frame())
     rGtkDataFrameNew(frame = data.frame())
     rGtkDataFrameAppendColumns(x, ...)
     rGtkDataFrameAppendRows(x, ...)
     as.data.frame.RGtkDataFrame(x, ...)
     rGtkDataFrameSetFrame(x, frame = data.frame())
     "[.RGtkDataFrame"(x, i, j, drop = T)
     "[<-.RGtkDataFrame"(x, i, j, value)
     dim.RGtkDataFrame(x, ...)
     dimnames.RGtkDataFrame(x, ...)
     "dimnames<-.RGtkDataFrame"(x, value)

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

   frame: The frame to use as the backing store of the model

       x: An 'RGtkDataFrame' object

       i: Row index

       j: Column index

   value: An R object similar to that accepted by '[<-.data.frame' or
          the dimnames for the data frame

    drop: Whether to 'drop' the result to the simplest structure

     ...: Items to append as columns or rows or just additional
          arguments

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

     The RGtk2 interface carries a lot of overhead, slowing down
     operations that require  large numbers of function calls, such as
     loading a GtkTreeModel. Under the assumption  that R programmers
     will store large datasets as data frames, a new 'GtkTreeModel' 
     was implemented that draws data directly from an R data frame.
     This offers not only a  dramatic performance gain but also allows
     efficient addition of columns to a model,  which the default GTK
     implementations do not allow.

     The 'RGtkDataFrame' is constructed with a delegate data frame,
     which can be empty,  via either 'rGtkDataFrameNew' or
     'rGtkDataFrame' for short. The subset and  replacement methods
     work much the same as for normal data frames, except one should
     note that  removing columns (ie by replacing columns with 'NULL's)
     is not supported. Note that even if the initial data frame is
     empty, one should ensure that the empty vectors  representing the
     column are of the desired types. If one wants to simply replace
     the backing frame with a new one, then there are two options:
     create a new RGtkDataFrame and connect it to the views of the old
     model, or use 'rGtkDataFrameSetFrame'.

     The 'rGtkDataFrameAppendColumns' and 'rGtkDataFrameAppendRows' 
     methods allow appending columns and rows, respectively.  Note that
     these are a lot shorter if using the 'object$appendColumns(...)'
     syntax.

     The 'as.data.frame' method retrieves the backing data frame from
     the model, so that one  can perform any data frame operation on
     the data. Of course, any changes are _not_  propagated back to the
     model, so it may take some work to efficiently merge any changes,
     if necessary.

     For convenience, one can access the dimensions and dimension names
     using 'dim.RGtkDataframe' and 'dimnames.RGtkDataFrame',
     respectively. It is possible to set the dimension names using the
     conventional replacement function. Note that rownames mean nothing
     to GTK.

_V_a_l_u_e:

     The constructors return instances of 'RGtkDataFrame'.
     'as.data.frame.RGtkDataFrame' returns the data frame backing the
     model. '[.RGtkDataFrame' returns the result of the '[' method on
     the backing frame.

_N_o_t_e:

     It is not yet clear how to encode a tree structure with a data
     frame, so this is  only currently useful for flat tables.

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

     Michael Lawrence

