dataentry                package:base                R Documentation

_S_p_r_e_a_d_s_h_e_e_t _I_n_t_e_r_f_a_c_e _f_o_r _E_n_t_e_r_i_n_g _D_a_t_a

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

     A spreadsheet-like editor for entering or editing data.

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

     data.entry(..., Modes = NULL, Names = NULL)
     dataentry(data, modes)
     de(..., Modes = NULL, Names = NULL)

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

     ...: A list of variables: currently these should be numeric or
          character vectors or list containing such vectors.

   Modes: The modes to be used for the variables.

   Names: The names to be used for the variables.

    data: A list of numeric and/or character vectors.

   modes: A list of length up to that of `data' giving the modes of
          (some of) the variables. `list()' is allowed.

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

     The data entry editor is only available on some platforms and
     GUIs. Where available it provides a means to visually edit a
     matrix or a collection of variables (including a data frame) as
     described in the ``Notes'' section.

     `data.entry' has side effects, any changes made in the spreadsheet
     are reflected in the variables.  The functions `de', `de.ncols',
     `de.setup' and `de.restore' are designed to help achieve these
     side effects. If the user passes in a matrix, `X' say, then the
     matrix is broken into columns before `dataentry' is called. Then
     on return the columns are collected and glued back together and
     the result assigned to the variable `X'.  If you don't want this
     behaviour use dataentry directly.

     The primitive function is `dataentry'. It takes a list of vectors
     of possibly different lengths and modes (the second argument) and
     opens a spreadsheet with these variables being the columns. The
     columns of the dataentry window are returned as vectors in a list
     when the spreadsheet is closed.

     `de.ncols' counts the number of columns which are supplied as
     arguments to `data.entry'. It attempts to count columns in lists,
     matrices and vectors.  `de.setup' sets things up so that on return
     the columns can be regrouped and reassigned to the correct name.
     This is handled by `de.restore'.

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

     `de' and `dataentry' return the edited value of their arguments.
     `data.entry' invisibly returns a vector of variable names but its
     main value is its side effect of assigning new version of those
     variables in the user's workspace.

_N_o_t_e:

     The details of interface to the data grid may differ by platform
     and GUI.  The following description applies to the GraphApp-based
     implementation under Windows.

     You can navigate around the grid using the cursor keys or by
     clicking with the (left) mouse button on any cell.  The active
     cell is highlighted by thickening the surrounding rectangle. 
     Moving to the right or down will scroll the grid as needed: there
     is no constraint to the rows or columns currently in use.

     The are alternative ways to navigate using the keys.  Return and
     (keypad) Enter and LineFeed all move down. Tab moves right and
     Shift-Tab move left.  Home moves to the top left.

     PageDown or Control-F moves down a page, and PageUp or Control-B
     up by a page.  End will show the last used column and the last few
     rows used (in any column).

     Using any other key starts an editing process on the currently
     selected cell: moving away from that cell enters the edited value
     whereas Esc cancels the edit and restores the previous value. 
     When the editing process starts the cell is cleared. The cursor
     changes to an I-beam to indicate that the cell is in enter mode.
     In numerical columns (the default) only letters making up a valid
     number (including `-.eE') are accepted, and entering an invalid
     edited value (such as blank) enters `NA' in that cell.  The last
     entered value can be deleted using the  BackSpace or Del(ete) key.
      Only a limited number of characters (currently 29) can be entered
     in a cell, and if necessary only the start or end of the string
     will be displayed, with the omissions indicated by `>' or `<'. 
     (The start is shown except when editing.)

     Double-clicking on a cell selects the cell and makes it into an
     editable field (a cursor will appear at the end of the text and it
     will change to the text highlight colour).  The edited text is
     entered by selecting another cell, for example by hitting Return.
     There is no way to cancel the edits.  The field will be expanded
     to the right if necessary to accommodate existing long strings, so
     it is preferable not to edit in the right-most displayed column. 
     (The editable field is itself scrollable.)

     Entering a value in a cell further down a column than the last
     used cell extends the variable and fills the gap (if any) by `NA's
     (not shown on screen).

     The column names can only be selected by clicking in them.  This
     gives a popup menu to select the column type (currently Real
     (numeric) or Character) or to change the name.  Changing the type
     converts the current contents of the column (and converting from
     Character to Real may generate `NA's.) Enter the changes made in
     the popup window by clicking on its close box.

     New columns are created by entering values in them (and not by
     just assigning a new name).  The mode of the column is
     auto-detected from the first value entered: if this is a valid
     number it gives a numeric column.  Unused columns are ignored, so
     adding data in `var5' to a three-column grid adds one extra
     variable, not two.

     There is a popup-menu accessed by right-clicking anywhere in the
     window that refers to the currently selected cell. This can copy
     the value to or paste from the clipboard, or paste in common
     values in that column. Copying and pasting can also be accessed by
     the usual keyboard shortcuts Control-C and Control-V.

     Columns can be resized by selecting and dragging a line (the
     cursor will change) within limits: columns must be between 4 and
     50 chars wide. The Autosize item on the popup menu will resize the
     currently selected column.

     Control-L will refresh the display, recalculating field widths to
     fit the current entries.

     In the default mode the column widths are chosen to fit the
     contents of each column, with a default of 10 characters for empty
     columns. you can specify fixed column widths by setting option
     `de.cellwidth' to the required fixed width (in characters). (set
     it to zero to return to variable widths).  The displayed width of
     any field is limited to 50 characters (and by the window width).

_S_e_e _A_l_s_o:

     `vi', `edit': `edit' uses `dataentry' to edit data frames.

_E_x_a_m_p_l_e_s:

     # call data entry with variables x and y
     data.entry(x,y)

