GtkEditable              package:RGtk2              R Documentation

_G_t_k_E_d_i_t_a_b_l_e

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

     Interface for text-editing widgets

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

     'gtkEditableSelectRegion(object, start, end)'
      'gtkEditableGetSelectionBounds(object)'
      'gtkEditableInsertText(object, new.text, position = 0)'
      'gtkEditableDeleteText(object, start.pos, end.pos)'
      'gtkEditableGetChars(object, start.pos, end.pos)'
      'gtkEditableCutClipboard(object)'
      'gtkEditableCopyClipboard(object)'
      'gtkEditablePasteClipboard(object)'
      'gtkEditableDeleteSelection(object)'
      'gtkEditableSetPosition(object, position)'
      'gtkEditableGetPosition(object)'
      'gtkEditableSetEditable(object, is.editable)'
      'gtkEditableGetEditable(object)'

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

     GInterface
        +----GtkEditable 

_I_m_p_l_e_m_e_n_t_a_t_i_o_n_s:

     GtkEditable is implemented by 'GtkEntry',  GtkText, 
     'GtkOldEditable' and  'GtkSpinButton'.

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

     The 'GtkEditable' interface is an interface which should be
     implemented by text editing widgets, such as 'GtkEntry' and
     'GtkText'. It contains functions  for generically manipulating an
     editable widget, a large number of action  signals used for key
     bindings, and several signals that an application can  connect to
     to modify the behavior of a widget. 

     As an example of the latter usage, by connecting the following
     handler to "insert_text", an application can convert all entry
     into a widget into uppercase.

     _Forcing entry to uppercase._


     insert_text_handler <- function(editable, text, length, position,
     id)
     {
       result <- toupper(text)
       gSignalHandlerBlock(editable, id)
       editable$insertText(result, length, position)
       gSignalHandlerUnblock(editable, id)
     }


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


     '_G_t_k_E_d_i_t_a_b_l_e' The 'GtkEditable' structure contains the following
          fields. (These fields should be considered read-only. They
          should never be set by an application.)

            'numeric'   selection_start;  the starting position of the selected characters  in the widget.
            'numeric'   selection_end;    the end position of the selected characters  in the widget.
            'numeric'   editable;         a flag indicating whether or not the widget is editable by the user.


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


     '_c_h_a_n_g_e_d(_e_d_i_t_a_b_l_e, _u_s_e_r._d_a_t_a)' Indicates that the user has changed
          the contents of the widget.

          '_e_d_i_t_a_b_l_e' ['GtkEditable'] 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.


     '_d_e_l_e_t_e-_t_e_x_t(_e_d_i_t_a_b_l_e, _s_t_a_r_t._p_o_s, _e_n_d._p_o_s, _u_s_e_r._d_a_t_a)' This signal
          is emitted when text is deleted from the widget by the user.
          The default handler for this signal will normally be
          responsible for inserting the text, so by connecting to this
          signal and then stopping the signal with
          'gtkSignalEmitStop()', it is possible to modify the inserted
          text, or prevent it from being inserted entirely. The
          'start.pos' and 'end.pos' parameters are interpreted as for
          'gtkEditableDeleteText'

          '_e_d_i_t_a_b_l_e' ['GtkEditable'] the object which received the
               signal.

          '_s_t_a_r_t._p_o_s' [integer] the starting position.

          '_e_n_d._p_o_s' [integer] the end position.

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


     '_i_n_s_e_r_t-_t_e_x_t(_e_d_i_t_a_b_l_e, _n_e_w._t_e_x_t, _n_e_w._t_e_x_t._l_e_n_g_t_h, _p_o_s_i_t_i_o_n, _u_s_e_r._d_a_t_a)' 
          This signal is emitted when text is inserted into the widget
          by the user. The default handler for this signal will
          normally be responsible for inserting the text, so by
          connecting to this signal and then stopping the signal with
          'gtkSignalEmitStop()', it is possible to modify the inserted
          text, or prevent it from being inserted entirely.

          '_e_d_i_t_a_b_l_e' ['GtkEditable'] the object which received the
               signal.

          '_n_e_w._t_e_x_t' [character] the new text to insert.

          '_n_e_w._t_e_x_t._l_e_n_g_t_h' [integer] the length of the new text, in
               bytes,  or -1 if new_text is nul-terminated

          '_p_o_s_i_t_i_o_n' [integer] the position, in characters, at which to
               insert  the new text. this is an in-out parameter. 
               After the signal emission is finished, it should  point
               after the newly inserted text.

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


_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/GtkEditable.html>

