GtkWidget               package:RGtk2               R Documentation

_G_t_k_W_i_d_g_e_t

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

     Base class for all widgets

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

     'gtkWidgetNew(type, ..., show = TRUE)'
      'gtkWidgetDestroy(object, ...)'
      'gtkWidgetSet(obj, ...)'
      'gtkWidgetUnparent(object)'
      'gtkWidgetShow(object)'
      'gtkWidgetShowNow(object)'
      'gtkWidgetHide(object)'
      'gtkWidgetShowAll(object)'
      'gtkWidgetHideAll(object)'
      'gtkWidgetMap(object)'
      'gtkWidgetUnmap(object)'
      'gtkWidgetRealize(object)'
      'gtkWidgetUnrealize(object)'
      'gtkWidgetQueueDraw(object)'
      'gtkWidgetQueueResize(object)'
      'gtkWidgetQueueResizeNoRedraw(object)'
      'gtkWidgetDraw(object, area)'
      'gtkWidgetSizeRequest(object)'
      'gtkWidgetGetChildRequisition(object)'
      'gtkWidgetSizeAllocate(object, allocation)'
      'gtkWidgetAddAccelerator(object, accel.signal, accel.group,
     accel.key, accel.mods, accel.flags)'
      'gtkWidgetRemoveAccelerator(object, accel.group, accel.key,
     accel.mods)'
      'gtkWidgetSetAccelPath(object, accel.path, accel.group)'
      'gtkWidgetListAccelClosures(object)'
      'gtkWidgetCanActivateAccel(object, signal.id)'
      'gtkWidgetEvent(object, event)'
      'gtkWidgetActivate(object)'
      'gtkWidgetReparent(object, new.parent)'
      'gtkWidgetIntersect(object, area, intersection)'
      'gtkWidgetIsFocus(object)'
      'gtkWidgetGrabFocus(object)'
      'gtkWidgetGrabDefault(object)'
      'gtkWidgetSetName(object, name)'
      'gtkWidgetGetName(object)'
      'gtkWidgetSetState(object, state)'
      'gtkWidgetSetSensitive(object, sensitive)'
      'gtkWidgetSetParent(object, parent)'
      'gtkWidgetSetParentWindow(object, parent.window)'
      'gtkWidgetGetParentWindow(object)'
      'gtkWidgetSetUposition(object, x, y)'
      'gtkWidgetSetUsize(object, width, height)'
      'gtkWidgetSetEvents(object, events)'
      'gtkWidgetAddEvents(object, events)'
      'gtkWidgetSetExtensionEvents(object, mode)'
      'gtkWidgetGetExtensionEvents(object)'
      'gtkWidgetGetToplevel(object)'
      'gtkWidgetGetAncestor(object, widget.type)'
      'gtkWidgetGetColormap(object)'
      'gtkWidgetSetColormap(object, colormap)'
      'gtkWidgetGetVisual(object)'
      'gtkWidgetGetEvents(object)'
      'gtkWidgetGetPointer(object)'
      'gtkWidgetIsAncestor(object, ancestor)'
      'gtkWidgetTranslateCoordinates(object, dest.widget, src.x,
     src.y)'
      'gtkWidgetHideOnDelete(object)'
      'gtkWidgetSetStyle(object, style = NULL)'
      'gtkWidgetEnsureStyle(object)'
      'gtkWidgetGetStyle(object)'
      'gtkWidgetResetRcStyles(object)'
      'gtkWidgetPushColormap(cmap)'
      'gtkWidgetPopColormap()'
      'gtkWidgetSetDefaultColormap(colormap)'
      'gtkWidgetGetDefaultStyle()'
      'gtkWidgetGetDefaultColormap()'
      'gtkWidgetGetDefaultVisual()'
      'gtkWidgetSetDirection(object, dir)'
      'gtkWidgetGetDirection(object)'
      'gtkWidgetSetDefaultDirection(dir)'
      'gtkWidgetGetDefaultDirection()'
      'gtkWidgetShapeCombineMask(object, shape.mask, offset.x,
     offset.y)'
      'gtkWidgetInputShapeCombineMask(object, shape.mask = NULL,
     offset.x, offset.y)'
      'gtkWidgetPath(object)'
      'gtkWidgetClassPath(object)'
      'gtkWidgetGetCompositeName(object)'
      'gtkWidgetModifyStyle(object, style)'
      'gtkWidgetGetModifierStyle(object)'
      'gtkWidgetModifyFg(object, state, color = NULL)'
      'gtkWidgetModifyBg(object, state, color = NULL)'
      'gtkWidgetModifyText(object, state, color = NULL)'
      'gtkWidgetModifyBase(object, state, color = NULL)'
      'gtkWidgetModifyFont(object, font.desc = NULL)'
      'gtkWidgetModifyCursor(object, primary, secondary)'
      'gtkWidgetCreatePangoContext(object)'
      'gtkWidgetGetPangoContext(object)'
      'gtkWidgetCreatePangoLayout(object, text)'
      'gtkWidgetRenderIcon(object, stock.id, size, detail = NULL)'
      'gtkWidgetPopCompositeChild()'
      'gtkWidgetPushCompositeChild()'
      'gtkWidgetQueueClear(object)'
      'gtkWidgetQueueClearArea(object, x, y, width, height)'
      'gtkWidgetQueueDrawArea(object, x, y, width, height)'
      'gtkWidgetResetShapes(object)'
      'gtkWidgetSetAppPaintable(object, app.paintable)'
      'gtkWidgetSetDoubleBuffered(object, double.buffered)'
      'gtkWidgetSetRedrawOnAllocate(object, redraw.on.allocate)'
      'gtkWidgetSetCompositeName(object, name)'
      'gtkWidgetSetScrollAdjustments(object, hadjustment = NULL,
     vadjustment = NULL)'
      'gtkWidgetMnemonicActivate(object, group.cycling)'
      'gtkWidgetClassInstallStyleProperty(klass, pspec)'
      'gtkWidgetClassInstallStylePropertyParser(klass, pspec, parser)'
      'gtkWidgetClassFindStyleProperty(klass, property.name)'
      'gtkWidgetClassListStyleProperties(klass)'
      'gtkWidgetRegionIntersect(object, region)'
      'gtkWidgetSendExpose(object, event)'
      'gtkWidgetStyleGet(object, ...)'
      'gtkWidgetStyleGetProperty(object, property.name)'
      'gtkWidgetGetAccessible(object)'
      'gtkWidgetChildFocus(object, direction)'
      'gtkWidgetChildNotify(object, child.property)'
      'gtkWidgetFreezeChildNotify(object)'
      'gtkWidgetGetChildVisible(object)'
      'gtkWidgetGetParent(object)'
      'gtkWidgetGetSettings(object)'
      'gtkWidgetGetClipboard(object, selection)'
      'gtkWidgetGetDisplay(object)'
      'gtkWidgetGetRootWindow(object)'
      'gtkWidgetGetScreen(object)'
      'gtkWidgetHasScreen(object)'
      'gtkWidgetGetSizeRequest(object)'
      'gtkWidgetSetChildVisible(object, is.visible)'
      'gtkWidgetSetSizeRequest(object, width, height)'
      'gtkWidgetThawChildNotify(object)'
      'gtkWidgetSetNoShowAll(object, no.show.all)'
      'gtkWidgetGetNoShowAll(object)'
      'gtkWidgetListMnemonicLabels(object)'
      'gtkWidgetAddMnemonicLabel(object, label)'
      'gtkWidgetRemoveMnemonicLabel(object, label)'
      'gtkWidgetGetAction(object)'
      'gtkWidgetIsComposited(object)'
      'gtkWidgetErrorBell(object)'
      'gtkWidgetKeynavFailed(object, direction)'
      'gtkWidgetGetTooltipMarkup(object)'
      'gtkWidgetSetTooltipMarkup(object, markup)'
      'gtkWidgetGetTooltipText(object)'
      'gtkWidgetSetTooltipText(object, text)'
      'gtkWidgetGetTooltipWindow(object)'
      'gtkWidgetSetTooltipWindow(object, custom.window)'
      'gtkWidgetGetHasTooltip(object)'
      'gtkWidgetSetHasTooltip(object, has.tooltip)'
      'gtkWidgetTriggerTooltipQuery(object)'
      'gtkRequisitionCopy(object)'
      'gtkWidget(type, ..., show = TRUE)'

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

     GObject
        +----GInitiallyUnowned
              +----GtkObject
                    +----GtkWidget
                          +----GtkContainer
                          +----GtkMisc
                          +----GtkCalendar
                          +----GtkCellView
                          +----GtkDrawingArea
                          +----GtkEntry
                          +----GtkRuler
                          +----GtkRange
                          +----GtkSeparator
                          +----GtkInvisible
                          +----GtkOldEditable
                          +----GtkPreview
                          +----GtkProgress 

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

     GtkWidget implements AtkImplementorIface and  'GtkBuildable'.

_I_n_t_e_r_f_a_c_e _D_e_r_i_v_a_t_i_o_n_s:

     GtkWidget is required by 'GtkFileChooser' and  'GtkCellEditable'.

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

     'GtkWidget' introduces style  properties - these are basically
     object properties that are stored not on the object, but in the
     style object associated to the widget. Style properties are set in
     resource files. This mechanism is used for configuring such things
     as the location of the scrollbar arrows through the theme, giving
     theme authors more control over the look of applications without
     the need to write a theme engine in C.

     Use 'gtkWidgetClassInstallStyleProperty' to install style
     properties for  a widget class, 'gtkWidgetClassFindStyleProperty'
     or 'gtkWidgetClassListStyleProperties' to get information about
     existing style properties and 'gtkWidgetStyleGetProperty',
     'gtkWidgetStyleGet' or 'gtkWidgetStyleGetValist()' to obtain the
     value of a style property.

_G_t_k_W_i_d_g_e_t _a_s _G_t_k_B_u_i_l_d_a_b_l_e:

     The GtkWidget implementation of the GtkBuildable interface
     supports a  custom <accelerator> element, which has attributes
     named key,  modifiers and signal and allows to specify
     accelerators.

     _A UI definition fragment specifying an accelerator_ <object
     class="GtkButton">
       <accelerator key="q" modifiers="GDK_CONTROL_MASK"
     signal="clicked"/>
     </object>
      In addition to accelerators,   'GtkWidget'   also support a 
     custom <accessible> element, which supports actions and relations.
      Properties on the accessible implementation of an object can be
     set by accessing the  internal child "accessible" of a  
     'GtkWidget'  .

     _A UI definition fragment specifying an accessible_ <object
     class="GtkButton" id="label1"/>
       <property name="label">I am a Label for a Button</property>
     </object>
     <object class="GtkButton" id="button1">
       <accessibility>
         <action action_name="click" description="Click the button."/>
         <relation target="label1" type="labelled-by"/>
       </accessibility>
       <child internal-child="accessible">
         <object class="AtkObject" id="a11y-button1">
           <property name="AtkObject::name">Clickable Button</property>
         </object>
       </child>
     </object>


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


     '_G_t_k_W_i_d_g_e_t' _undocumented _

          '_s_t_y_l_e' ['GtkStyle'] The style for the widget. The style
               contains the colors the widget should be  drawn in for
               each state along with graphics contexts used to draw
               with and the font  to use for text.

          '_r_e_q_u_i_s_i_t_i_o_n' ['GtkRequisition'] The widget's desired size.

          '_a_l_l_o_c_a_t_i_o_n' ['GtkAllocation'] The widget's allocated size.

          '_w_i_n_d_o_w' ['GdkWindow'] The widget's window or its parent
               window if it does not have a window. (Which  will be
               indicated by the 'GTK_NO_WINDOW' flag being set).

          '_p_a_r_e_n_t' ['GtkWidget'] 


     '_G_t_k_W_i_d_g_e_t_C_l_a_s_s' 'activate_signal' The signal to emit when a
          widget of this class is activated, 'gtkWidgetActivate'
          handles the emission. Implementation of this signal is
          optional.  'set_scroll_adjustment_signal' This signal is
          emitted  when a widget of this class is added to a scrolling
          aware parent, 'gtkWidgetSetScrollAdjustments' handles the
          emission. Implementation of this signal is optional.


     '_G_t_k_R_e_q_u_i_s_i_t_i_o_n' A 'GtkRequisition' represents the desired size of
          a widget. See  for more information.

          '_w_i_d_t_h' [integer] the widget's desired width

          '_h_e_i_g_h_t' [integer] the widget's desired height


     '_G_t_k_S_e_l_e_c_t_i_o_n_D_a_t_a' _undocumented _

          '_s_e_l_e_c_t_i_o_n' ['GdkAtom'] 

          '_t_a_r_g_e_t' ['GdkAtom'] 

          '_t_y_p_e' ['GdkAtom'] 

          '_f_o_r_m_a_t' [integer] 

          '_d_a_t_a' [raw] 


_C_o_n_v_e_n_i_e_n_t _C_o_n_s_t_r_u_c_t_i_o_n:

     'gtkWidget' is the equivalent of 'gtkWidgetNew'.

_E_n_u_m_s _a_n_d _F_l_a_g_s:


     '_G_t_k_W_i_d_g_e_t_F_l_a_g_s' Tells about certain properties of the widget.

          '_t_o_p_l_e_v_e_l' widgets without a real parent, as there are
               'GtkWindow's and 'GtkMenu's have this flag set
               throughout their lifetime. Toplevel widgets always
               contain their own 'GdkWindow'.

          '_n_o-_w_i_n_d_o_w' Indicative for a widget that does not provide its
               own 'GdkWindow'.  Visible action (e.g. drawing) is
               performed on the parent's 'GdkWindow'.

          '_r_e_a_l_i_z_e_d' Set by 'gtkWidgetRealize', unset by
               'gtkWidgetUnrealize'. A realized widget has an
               associated 'GdkWindow'.

          '_m_a_p_p_e_d' Set by 'gtkWidgetMap', unset by 'gtkWidgetUnmap'.
               Only realized widgets can be mapped. It means that
               'gdkWindowShow'  has been called on the widgets
               window(s).

          '_v_i_s_i_b_l_e' Set by 'gtkWidgetShow', unset by 'gtkWidgetHide'.
               Implies that a  widget will be mapped as soon as its
               parent is mapped.

          '_s_e_n_s_i_t_i_v_e' Set and unset by 'gtkWidgetSetSensitive'. The
               sensitivity of a widget determines whether it will
               receive certain events (e.g. button or key presses). One
               premise for the widget's sensitivity is to have this
               flag set.

          '_p_a_r_e_n_t-_s_e_n_s_i_t_i_v_e' Set and unset by 'gtkWidgetSetSensitive'
               operations on the parents of the widget. This is the
               second premise for the widget's sensitivity. Once it has
               'GTK_SENSITIVE' and 'GTK_PARENT_SENSITIVE' set, its
               state is effectively sensitive. This is expressed (and
               can be examined) by the 'GTK_WIDGET_IS_SENSITIVE'
               function.

          '_c_a_n-_f_o_c_u_s' Determines whether a widget is able to handle
               focus grabs.

          '_h_a_s-_f_o_c_u_s' Set by 'gtkWidgetGrabFocus' for widgets that also
               have 'GTK_CAN_FOCUS' set. The flag will be unset once
               another widget grabs the focus.

          '_c_a_n-_d_e_f_a_u_l_t' The widget is allowed to receive the default
               action via  'gtkWidgetGrabDefault'.

          '_h_a_s-_d_e_f_a_u_l_t' The widget currently is receiving the default
               action.

          '_h_a_s-_g_r_a_b' Set by 'gtkGrabAdd', unset by 'gtkGrabRemove'. It
               means that the  widget is in the grab_widgets stack, and
               will be the preferred one for  receiving events other
               than ones of cosmetic value.

          '_r_c-_s_t_y_l_e' Indicates that the widget's style has been looked
               up through the rc  mechanism. It does not imply that the
               widget actually had a style  defined through the rc
               mechanism.

          '_c_o_m_p_o_s_i_t_e-_c_h_i_l_d' Indicates that the widget is a composite
               child of its parent; see  'gtkWidgetPushCompositeChild',
               'gtkWidgetPopCompositeChild'.

          '_n_o-_r_e_p_a_r_e_n_t' Unused since before GTK+ 1.2, will be removed
               in a future version.

          '_a_p_p-_p_a_i_n_t_a_b_l_e' Set and unset by 'gtkWidgetSetAppPaintable'.
               Must be set on widgets whose window the application
               directly draws on,  in order to keep GTK+ from
               overwriting the drawn stuff.

          '_r_e_c_e_i_v_e_s-_d_e_f_a_u_l_t' The widget when focused will receive the
               default action and have  'GTK_HAS_DEFAULT' set even if
               there is a different widget set as default.

          '_d_o_u_b_l_e-_b_u_f_f_e_r_e_d' Set and unset by
               'gtkWidgetSetDoubleBuffered'. Indicates that exposes
               done on the widget should be double-buffered.

          '_n_o-_s_h_o_w-_a_l_l' _undocumented _


     '_G_t_k_W_i_d_g_e_t_H_e_l_p_T_y_p_e' _undocumented _

          '_t_o_o_l_t_i_p' _undocumented _

          '_w_h_a_t_s-_t_h_i_s' _undocumented _


     '_G_t_k_T_e_x_t_D_i_r_e_c_t_i_o_n' _undocumented _

          '_n_o_n_e' _undocumented _

          '_l_t_r' _undocumented _

          '_r_t_l' _undocumented _


_U_s_e_r _F_u_n_c_t_i_o_n_s:


     '_G_t_k_C_a_l_l_b_a_c_k(_w_i_d_g_e_t, _d_a_t_a)' The type of the callback functions
          used for e.g. iterating over the children of a container, see
          'gtkContainerForeach'. 

          '_w_i_d_g_e_t' ['GtkWidget'] the widget to operate on

          '_d_a_t_a' [R object] user-supplied data


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


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

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_b_u_t_t_o_n-_p_r_e_s_s-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::button-press-event signal will be emitted when a button
          (typically from a mouse) is pressed.

          To receive this signal, the 'GdkWindow' associated to the 
          widget needs to enable the 'GDK_BUTTON_PRESS_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEventButton']  the 'GdkEventButton' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_b_u_t_t_o_n-_r_e_l_e_a_s_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::button-release-event signal will be emitted when a button
          (typically from a mouse) is released.

          To receive this signal, the 'GdkWindow' associated to the 
          widget needs to enable the 'GDK_BUTTON_RELEASE_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEventButton']  the 'GdkEventButton' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_c_a_n-_a_c_t_i_v_a_t_e-_a_c_c_e_l(_w_i_d_g_e_t, _s_i_g_n_a_l._i_d, _u_s_e_r._d_a_t_a)' Determines
          whether an accelerator that activates the signal identified
          by 'signal.id' can currently be activated. This signal is
          present to allow applications and derived widgets to override
          the default 'GtkWidget' handling for determining whether an
          accelerator can be activated.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_s_i_g_n_a_l._i_d' [numeric]  the ID of a signal installed on
               'widget'

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

          _Returns:_ [logical] 'TRUE' if the signal can be activated.


     '_c_h_i_l_d-_n_o_t_i_f_y(_w_i_d_g_e_t, _p_s_p_e_c, _u_s_e_r._d_a_t_a)' The ::child-notify signal
          is emitted for each  child property  that has changed on an
          object. The signal's detail holds the property name.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_p_s_p_e_c' ['GParamSpec']  the 'GParamSpec' of the changed child
               property

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


     '_c_l_i_e_n_t-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::client-event will
          be emitted when the 'widget''s window receives a message (via
          a ClientMessage event) from another application.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventClient']  the 'GdkEventClient' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for  the event. 'FALSE' to propagate the event
          further.


     '_c_o_m_p_o_s_i_t_e_d-_c_h_a_n_g_e_d(_w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' The ::composited-changed
          signal is emitted when the composited status of 'widget's
          screen changes.  See 'gdkScreenIsComposited'.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object on which the signal is
               emitted

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


     '_c_o_n_f_i_g_u_r_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::configure-event
          signal will be emitted when the size, position or stacking of
          the 'widget''s window has changed.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_STRUCTURE_MASK' mask. GDK
          will enable this mask automatically for all new windows.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventConfigure']  the 'GdkEventConfigure' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_d_e_l_e_t_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::delete-event signal
          is emitted if a user requests that a toplevel window is
          closed. The default handler for this signal destroys the
          window. Connecting 'gtkWidgetHideOnDelete' to this signal
          will cause the window to be hidden instead, so that it can
          later be shown again without reconstructing it.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEvent']  the event which triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_d_e_s_t_r_o_y-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::destroy-event
          signal is emitted when a 'GdkWindow' is destroyed. You rarely
          get this signal, because most widgets disconnect themselves 
          from their window before they destroy it, so no widget owns
          the  window at destroy time.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_STRUCTURE_MASK' mask. GDK
          will enable this mask automatically for all new windows.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEvent']  the event which triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_d_i_r_e_c_t_i_o_n-_c_h_a_n_g_e_d(_w_i_d_g_e_t, _p_r_e_v_i_o_u_s._d_i_r_e_c_t_i_o_n, _u_s_e_r._d_a_t_a)' The
          ::direction-changed signal is emitted when the text direction
          of a widget changes.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object on which the signal is
               emitted

          '_p_r_e_v_i_o_u_s._d_i_r_e_c_t_i_o_n' ['GtkTextDirection']  the previous text
               direction of 'widget'

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


     '_d_r_a_g-_b_e_g_i_n(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _u_s_e_r._d_a_t_a)' The ::drag-begin
          signal is emitted on the drag source when a drag is  started.
          A typical reason to connect to this signal is to set up a 
          custom drag icon with 'gtkDragSourceSetIcon'.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

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


     '_d_r_a_g-_d_a_t_a-_d_e_l_e_t_e(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _u_s_e_r._d_a_t_a)' The
          ::drag-data-delete signal is emitted on the drag source when
          a drag  with the action 'GDK_ACTION_MOVE' is successfully
          completed. The signal  handler is responsible for deleting
          the data that has been dropped. What  "delete" means depends
          on the context of the drag operation.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

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


     '_d_r_a_g-_d_a_t_a-_g_e_t(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _d_a_t_a, _i_n_f_o, _t_i_m_e, _u_s_e_r._d_a_t_a)' 
          The ::drag-data-get signal is emitted on the drag source when
          the drop  site requests the data which is dragged. It is the
          responsibility of  the signal handler to fill 'data' with the
          data in the format which  is indicated by 'info'. See
          'gtkSelectionDataSet' and  'gtkSelectionDataSetText'.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

          '_d_a_t_a' ['GtkSelectionData']  the 'GtkSelectionData' to be
               filled with the dragged data

          '_i_n_f_o' [numeric]  the info that has been registered with the
               target in the  'GtkTargetList'

          '_t_i_m_e' [numeric]  the timestamp at which the data was
               requested

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


     '_d_r_a_g-_d_a_t_a-_r_e_c_e_i_v_e_d(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _x, _y, _d_a_t_a, _i_n_f_o, _t_i_m_e, _u_s_e_r._d_a_t_a)' 
          The ::drag-data-received signal is emitted on the drop site
          when the  dragged data has been received. If the data was
          received in order to  determine whether the drop will be
          accepted, the handler is expected  to call 'gdkDragStatus'
          and _not_ finish the drag.  If the data was received in
          response to a '"drag-drop"' signal  (and this is the last
          target to be received), the handler for this  signal is
          expected to process the received data and then call 
          'gtkDragFinish', setting the 'success' parameter depending on
          whether  the data was processed successfully. 

          The handler may inspect and modify 'drag.context->action'
          before calling  'gtkDragFinish', e.g. to implement
          'GDK_ACTION_ASK' as shown in the  following example:


          drag_data_received <- function(widget, drag_context, x, y,
          data, info, time)
          {
            if ((data[["length"]] >= 0) && (data[["format"]] == 8)) {
              if (drag_context[["action"]] == "ask")  {
                dialog <- gtkMessageDialog(NULL, c("modal",
          "destroy-with-parent"),
                                           "info", "yes-no", "Move the
          data ?")
                response <- dialog$run()
                dialog$destroy()

                gtkDragFinish(drag_context, TRUE, response == "yes",
          time)
              }
            } else gtkDragFinish(drag_context, FALSE, FALSE, time)
          }



          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

          '_x' [integer]  where the drop happened

          '_y' [integer]  where the drop happened

          '_d_a_t_a' ['GtkSelectionData']  the received data

          '_i_n_f_o' [numeric]  the info that has been registered with the
               target in the  'GtkTargetList'

          '_t_i_m_e' [numeric]  the timestamp at which the data was
               received

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


     '_d_r_a_g-_d_r_o_p(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _x, _y, _t_i_m_e, _r_e_t_u_r_n_s, _u_s_e_r._d_a_t_a)' 
          The ::drag-drop signal is emitted on the drop site when the
          user drops  the data onto the widget. The signal handler must
          determine whether  the cursor position is in a drop zone or
          not. If it is not in a drop  zone, it returns 'FALSE' and no
          further processing is necessary.  Otherwise, the handler
          returns 'TRUE'. In this case, the handler must  ensure that
          'gtkDragFinish' is called to let the source know that  the
          drop is done. The call to 'gtkDragFinish' can be done either 
          directly or in a '"drag-data-received"' handler which gets 
          triggered by calling 'gtkDragGetData' to receive the data for
          one  or more of the supported targets.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

          '_x' [integer]  the x coordinate of the current cursor
               position

          '_y' [integer]  the y coordinate of the current cursor
               position

          '_t_i_m_e' [numeric]  the timestamp of the motion event

          '_r_e_t_u_r_n_s' [R object]  whether the cursor position is in a
               drop zone

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


     '_d_r_a_g-_e_n_d(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _u_s_e_r._d_a_t_a)' The ::drag-end signal
          is emitted on the drag source when a drag is  finished.  A
          typical reason to connect to this signal is to undo  things
          done in '"drag-begin"'.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

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


     '_d_r_a_g-_f_a_i_l_e_d(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _r_e_s_u_l_t, _u_s_e_r._d_a_t_a)' The
          ::drag-failed signal is emitted on the drag source when a
          drag has failed. The signal handler may hook custom code to
          handle a failed DND operation based on the type of error, it
          returns 'TRUE' is the failure has been already handled (not
          showing the default "drag operation failed" animation),
          otherwise it returns 'FALSE'.  

          Since  2.12

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

          '_r_e_s_u_l_t' [GtkDragResult]  the result of the drag operation

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

          _Returns:_ [logical] 'TRUE' if the failed drag operation has
          been already handled.


     '_d_r_a_g-_l_e_a_v_e(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _t_i_m_e, _u_s_e_r._d_a_t_a)' The
          ::drag-leave signal is emitted on the drop site when the
          cursor  leaves the widget. A typical reason to connect to
          this signal is to  undo things done in '"drag-motion"', e.g.
          undo highlighting  with 'gtkDragUnhighlight'  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

          '_t_i_m_e' [numeric]  the timestamp of the motion event

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


     '_d_r_a_g-_m_o_t_i_o_n(_w_i_d_g_e_t, _d_r_a_g._c_o_n_t_e_x_t, _x, _y, _t_i_m_e, _r_e_t_u_r_n_s, _u_s_e_r._d_a_t_a)' 
          The ::drag-motion signal is emitted on the drop site when the
          user  moves the cursor over the widget during a drag. The
          signal handler  must determine whether the cursor position is
          in a drop zone or not.  If it is not in a drop zone, it
          returns 'FALSE' and no further processing  is necessary.
          Otherwise, the handler returns 'TRUE'. In this case, the 
          handler is responsible for providing the necessary
          information for  displaying feedback to the user, by calling
          'gdkDragStatus'. If the  decision whether the drop will be
          accepted or rejected can't be made based solely on the cursor
          position and the type of the data, the handler  may inspect
          the dragged data by calling 'gtkDragGetData' and defer the 
          'gdkDragStatus' call to the '"drag-data-received"' handler. 

          Note that there is no drag-enter signal. The drag receiver
          has to keep  track of whether he has received any drag-motion
          signals since the last  '"drag-leave"' and if not, treat the
          drag-motion signal as an  "enter" signal. Upon an "enter",
          the handler will typically highlight  the drop site with
          'gtkDragHighlight'.


          drag_motion <- function(widget, context, x, y, time)
          {
            state <- widget$getData("drag-state")

            if (!state$drag_highlight) {
              state$drag_highlight <- T
              gtkDragHighlight(widget)
            }

            target <- gtkDragDestFindTarget(widget, context, NULL)
            if (target == 0)
              gdkDragStatus(context, 0, time)
            else {
              state$pending_status <- context[["suggestedAction"]]
              gtkDragGetData(widget, context, target, time)
             }

            widget$setData("drag-state", state)

            return(TRUE)
          }

          drag_data_received <- function(widget, context, x, y,
          selection_data, info,
                                         time)
          {
            state <- widget$getData("drag-state")

            if (state$pending_status) { 
               ## We are getting this data due to a request in
          drag_motion,
               ## rather than due to a request in drag_drop, so we are
          just
               ## supposed to call gdk_drag_status(), not actually
          paste in the data.

              str <- gtkSelectionDataGetText(selection_data)
              if (!data_is_acceptable (str)) 
                gdkDragStatus(context, 0, time)
              else
                gdkDragStatus(context, state$pending_status, time)

              state$pending_status <- 0
            }
            else {
              ## accept the drop
            }

            widget$setData("drag-state", state)
          }


          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_r_a_g._c_o_n_t_e_x_t' ['GdkDragContext']  the drag context

          '_x' [integer]  the x coordinate of the current cursor
               position

          '_y' [integer]  the y coordinate of the current cursor
               position

          '_t_i_m_e' [numeric]  the timestamp of the motion event

          '_r_e_t_u_r_n_s' [R object]  whether the cursor position is in a
               drop zone

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


     '_e_n_t_e_r-_n_o_t_i_f_y-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::enter-notify-event will be emitted when the pointer enters
          the 'widget''s window.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_ENTER_NOTIFY_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventCrossing']  the 'GdkEventCrossing' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The GTK+ main loop will emit
          three signals for each GDK event delivered to a widget: one
          generic ::event signal, another, more specific, signal that
          matches the type of event delivered (e.g. 
          '"key-press-event"') and finally a generic  '"event-after"'
          signal.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEvent']  the 'GdkEvent' which triggered this
               signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event  and to cancel the emission of the
          second specific ::event signal. 'FALSE' to propagate the
          event further and to allow the emission of  the second
          signal. The ::event-after signal is emitted regardless of the
          return value.


     '_e_v_e_n_t-_a_f_t_e_r(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' After the emission of the
          'gtkWidgetEvent' signal and (optionally)  the second more
          specific signal, ::event-after will be emitted  regardless of
          the previous two signals handlers return values.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEvent']  the 'GdkEvent' which triggered this
               signal

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


     '_e_x_p_o_s_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::expose-event signal
          is emitted when an area of a previously obscured 'GdkWindow'
          is made visible and needs to be redrawn. 'GTK_NO_WINDOW'
          widgets will get a synthesized event from their parent 
          widget.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_EXPOSURE_MASK' mask.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEventExpose']  the 'GdkEventExpose' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_f_o_c_u_s(_w_i_d_g_e_t, _a_r_g_1, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_a_r_g_1' ['GtkDirectionType'] 

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event. 'FALSE' to propagate the event
          further.


     '_f_o_c_u_s-_i_n-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::focus-in-event
          signal will be emitted when the keyboard focus enters the
          'widget''s window.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_FOCUS_CHANGE_MASK' mask.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventFocus']  the 'GdkEventFocus' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_f_o_c_u_s-_o_u_t-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::focus-out-event
          signal will be emitted when the keyboard focus leaves the
          'widget''s window.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_FOCUS_CHANGE_MASK' mask.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventFocus']  the 'GdkEventFocus' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_g_r_a_b-_b_r_o_k_e_n-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' Emitted when a
          pointer or keyboard grab on a window belonging  to 'widget'
          gets broken. 

          On X11, this happens when the grab window becomes unviewable 
          (i.e. it or one of its ancestors is unmapped), or if the same
           application grabs the pointer or keyboard again.  

          Since  2.8

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEvent']  the 'GdkEventGrabBroken' event

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for  the event. 'FALSE' to propagate the event
          further.


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

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_g_r_a_b-_n_o_t_i_f_y(_w_i_d_g_e_t, _w_a_s._g_r_a_b_b_e_d, _u_s_e_r._d_a_t_a)' The ::grab-notify
          signal is emitted when a widget becomes shadowed by a GTK+
          grab (not a pointer or keyboard grab) on  another widget, or
          when it becomes unshadowed due to a grab  being removed.

          A widget is shadowed by a 'gtkGrabAdd' when the topmost  grab
          widget in the grab stack of its window group is not  its
          ancestor.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_w_a_s._g_r_a_b_b_e_d' [logical] 'FALSE' if the widget becomes
               shadowed, 'TRUE' if it becomes unshadowed

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


     '_h_i_d_e(_w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_h_i_e_r_a_r_c_h_y-_c_h_a_n_g_e_d(_w_i_d_g_e_t, _p_r_e_v_i_o_u_s._t_o_p_l_e_v_e_l, _u_s_e_r._d_a_t_a)' The
          ::hierarchy-changed signal is emitted when the anchored state
          of a widget changes. A widget is anchored when its toplevel
          ancestor is a 'GtkWindow'. This signal is emitted when a
          widget changes from un-anchored to anchored or vice-versa.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object on which the signal is
               emitted

          '_p_r_e_v_i_o_u_s._t_o_p_l_e_v_e_l' ['GtkWidget']  the previous toplevel
               ancestor, or 'NULL' if the widget was previously
               unanchored

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


     '_k_e_y-_p_r_e_s_s-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::key-press-event
          signal is emitted when a key is pressed.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_KEY_PRESS_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventKey']  the 'GdkEventKey' which triggered
               this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_k_e_y-_r_e_l_e_a_s_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::key-release-event signal is emitted when a key is pressed.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_KEY_RELEASE_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventKey']  the 'GdkEventKey' which triggered
               this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_k_e_y_n_a_v-_f_a_i_l_e_d(_w_i_d_g_e_t, _d_i_r_e_c_t_i_o_n, _u_s_e_r._d_a_t_a)' Gets emitted if
          keyboard navigation fails.  See 'gtkWidgetKeynavFailed' for
          details.  

          Since  2.12

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_d_i_r_e_c_t_i_o_n' ['GtkDirectionType']  the direction of movement

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

          _Returns:_ [logical] 'TRUE' if stopping keyboard navigation
          is fine, 'FALSE' if the emitting widget should try to handle
          the keyboard navigation attempt in its parent container(s).


     '_l_e_a_v_e-_n_o_t_i_f_y-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::leave-notify-event will be emitted when the pointer leaves
          the 'widget''s window.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_LEAVE_NOTIFY_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventCrossing']  the 'GdkEventCrossing' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_m_a_p(_w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_m_a_p-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::map-event signal will
          be emitted when the 'widget''s window is mapped. A window is
          mapped when it becomes visible on the screen.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_STRUCTURE_MASK' mask. GDK
          will enable this mask automatically for all new windows.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEvent']  the 'GdkEventAny' which triggered this
               signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


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

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_a_r_g_1' [logical] 

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


     '_m_o_t_i_o_n-_n_o_t_i_f_y-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::motion-notify-event signal is emitted when the pointer
          moves  over the widget's 'GdkWindow'.

          To receive this signal, the 'GdkWindow' associated to the
          widget  needs to enable the 'GDK_POINTER_MOTION_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEventMotion']  the 'GdkEventMotion' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


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

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_a_r_g_1' ['GtkDirectionType'] 

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


     '_n_o-_e_x_p_o_s_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::no-expose-event
          will be emitted when the 'widget''s window is  drawn as a
          copy of another 'GdkDrawable' (with 'gdkDrawDrawable' or
          'gdkWindowCopyArea()') which was completely unobscured. If
          the source window was partially obscured 'GdkEventExpose'
          events will be generated for those areas.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventNoExpose']  the 'GdkEventNoExpose' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_p_a_r_e_n_t-_s_e_t(_w_i_d_g_e_t, _o_l_d._p_a_r_e_n_t, _u_s_e_r._d_a_t_a)' The ::parent-set
          signal is emitted when a new parent  has been set on a
          widget.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object on which the signal is
               emitted

          '_o_l_d._p_a_r_e_n_t' ['GtkObject']  the previous parent, or 'NULL' if
               the widget  just got its initial parent.

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


     '_p_o_p_u_p-_m_e_n_u(_w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' This signal gets emitted whenever
          a widget should pop up a context  menu. This usually happens
          through the standard key binding mechanism;  by pressing a
          certain key while a widget is focused, the user can cause 
          the widget to pop up a menu.  For example, the 'GtkEntry'
          widget creates  a menu with clipboard commands. See   for an
          example of how to use this signal.  

          '_w_i_d_g_e_t' ['GtkWidget']  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.

          _Returns:_ [logical] 'TRUE' if a menu was activated


     '_p_r_o_p_e_r_t_y-_n_o_t_i_f_y-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::property-notify-event signal will be emitted when a
          property on the 'widget''s window has been changed or
          deleted.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_PROPERTY_CHANGE_MASK' mask.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventProperty']  the 'GdkEventProperty' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_p_r_o_x_i_m_i_t_y-_i_n-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' To receive this
          signal the 'GdkWindow' associated to the widget needs to
          enable the 'GDK_PROXIMITY_IN_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventProximity']  the 'GdkEventProximity' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_p_r_o_x_i_m_i_t_y-_o_u_t-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' To receive this
          signal the 'GdkWindow' associated to the widget needs to
          enable the 'GDK_PROXIMITY_OUT_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventProximity']  the 'GdkEventProximity' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_q_u_e_r_y-_t_o_o_l_t_i_p(_w_i_d_g_e_t, _x, _y, _k_e_y_b_o_a_r_d._m_o_d_e, _t_o_o_l_t_i_p, _u_s_e_r._d_a_t_a)' 
          Emitted when the '"gtk-tooltip-timeout"' has expired with 
          the cursor hovering "above" 'widget'; or emitted when
          'widget' got  focus in keyboard mode.

          Using the given coordinates, the signal handler should
          determine whether a tooltip should be shown for 'widget'. If
          this is the case 'TRUE' should be returned, 'FALSE'
          otherwise.  Note that if 'keyboard.mode' is 'TRUE', the
          values of 'x' and 'y' are undefined and should not be used.

          The signal handler is free to manipulate 'tooltip' with the
          therefore destined function calls.  

          Since  2.12

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_x' [integer]  the x coordinate of the cursor position where
               the request has  been emitted, relative to
               'widget->window'

          '_y' [integer]  the y coordinate of the cursor position where
               the request has  been emitted, relative to
               'widget->window'

          '_k_e_y_b_o_a_r_d._m_o_d_e' [logical] 'TRUE' if the tooltip was trigged
               using the keyboard

          '_t_o_o_l_t_i_p' ['GtkTooltip']  a 'GtkTooltip'

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

          _Returns:_ [logical] 'TRUE' if 'tooltip' should be shown
          right now, 'FALSE' otherwise.


     '_r_e_a_l_i_z_e(_w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_s_c_r_e_e_n-_c_h_a_n_g_e_d(_w_i_d_g_e_t, _p_r_e_v_i_o_u_s._s_c_r_e_e_n, _u_s_e_r._d_a_t_a)' The
          ::screen-changed signal gets emitted when the screen of a
          widget has changed.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object on which the signal is
               emitted

          '_p_r_e_v_i_o_u_s._s_c_r_e_e_n' ['GdkScreen']  the previous screen, or
               'NULL' if the widget was not associated with a screen
               before

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


     '_s_c_r_o_l_l-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::scroll-event signal
          is emitted when a button in the 4 to 7 range is pressed.
          Wheel mice are usually configured to generate  button press
          events for buttons 4 and 5 when the wheel is turned.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_BUTTON_PRESS_MASK' mask.

          This signal will be sent to the grab widget if there is one.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal.

          '_e_v_e_n_t' ['GdkEventScroll']  the 'GdkEventScroll' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_s_e_l_e_c_t_i_o_n-_c_l_e_a_r-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::selection-clear-event signal will be emitted when the the
          'widget''s window has lost ownership of a selection.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventSelection']  the 'GdkEventSelection' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_s_e_l_e_c_t_i_o_n-_g_e_t(_w_i_d_g_e_t, _d_a_t_a, _i_n_f_o, _t_i_m_e, _u_s_e_r._d_a_t_a)' _undocumented
          _

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_d_a_t_a' ['GtkSelectionData'] 

          '_i_n_f_o' [numeric] 

          '_t_i_m_e' [numeric] 

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


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

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_e_v_e_n_t' ['GdkEventSelection'] 

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event. 'FALSE' to propagate the event
          further.


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

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_d_a_t_a' ['GtkSelectionData'] 

          '_t_i_m_e' [numeric] 

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


     '_s_e_l_e_c_t_i_o_n-_r_e_q_u_e_s_t-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::selection-request-event signal will be emitted when another
          client requests ownership of the selection owned by the
          'widget''s window.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventSelection']  the 'GdkEventSelection' which
               triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


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

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_s_h_o_w-_h_e_l_p(_w_i_d_g_e_t, _a_r_g_1, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_a_r_g_1' ['GtkWidgetHelpType'] 

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


     '_s_i_z_e-_a_l_l_o_c_a_t_e(_w_i_d_g_e_t, _a_l_l_o_c_a_t_i_o_n, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_a_l_l_o_c_a_t_i_o_n' ['GtkAllocation'] 

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


     '_s_i_z_e-_r_e_q_u_e_s_t(_w_i_d_g_e_t, _r_e_q_u_i_s_i_t_i_o_n, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_r_e_q_u_i_s_i_t_i_o_n' ['GtkRequisition'] 

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


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

          '_w_i_d_g_e_t' ['GtkWidget'] the object which received the signal.

          '_s_t_a_t_e' ['GtkStateType'] 

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


     '_s_t_y_l_e-_s_e_t(_w_i_d_g_e_t, _p_r_e_v_i_o_u_s._s_t_y_l_e, _u_s_e_r._d_a_t_a)' The ::style-set
          signal is emitted when a new style has been set  on a widget.
          Note that style-modifying functions like 
          'gtkWidgetModifyBase' also cause this signal to be emitted.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object on which the signal is
               emitted

          '_p_r_e_v_i_o_u_s._s_t_y_l_e' ['GtkStyle']  the previous style, or 'NULL'
               if the widget  just got its initial style 

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


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

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_u_n_m_a_p-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The ::unmap-event signal
          will be emitted when the 'widget''s window is unmapped. A
          window is unmapped when it becomes invisible on the screen.

          To receive this signal, the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_STRUCTURE_MASK' mask. GDK
          will enable this mask automatically for all new windows.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEvent']  the 'GdkEventAny' which triggered this
               signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_u_n_r_e_a_l_i_z_e(_w_i_d_g_e_t, _u_s_e_r._d_a_t_a)' _undocumented _

          '_w_i_d_g_e_t' ['GtkWidget'] 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.


     '_v_i_s_i_b_i_l_i_t_y-_n_o_t_i_f_y-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::visibility-notify-event will be emitted when the 'widget''s
          window is obscured or unobscured.

          To receive this signal the 'GdkWindow' associated to the
          widget needs to enable the 'GDK_VISIBILITY_NOTIFY_MASK' mask.            

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventVisibility']  the 'GdkEventVisibility'
               which triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the event.  'FALSE' to propagate the event
          further.


     '_w_i_n_d_o_w-_s_t_a_t_e-_e_v_e_n_t(_w_i_d_g_e_t, _e_v_e_n_t, _u_s_e_r._d_a_t_a)' The
          ::window-state-event will be emitted when the state of the 
          toplevel window associated to the 'widget' changes.

          To receive this signal the 'GdkWindow' associated to the
          widget  needs to enable the 'GDK_STRUCTURE_MASK' mask. GDK
          will enable  this mask automatically for all new windows.  

          '_w_i_d_g_e_t' ['GtkWidget']  the object which received the signal

          '_e_v_e_n_t' ['GdkEventWindowState']  the 'GdkEventWindowState'
               which triggered this signal

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

          _Returns:_ [logical] 'TRUE' to stop other handlers from being
          invoked for the  event. 'FALSE' to propagate the event
          further.


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


     '_a_p_p-_p_a_i_n_t_a_b_l_e' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the application
          will paint directly on the widget.  Default value: FALSE


     '_c_a_n-_d_e_f_a_u_l_t' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget can be
          the default widget.  Default value: FALSE


     '_c_a_n-_f_o_c_u_s' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget can accept
          the input focus.  Default value: FALSE


     '_c_o_m_p_o_s_i_t_e-_c_h_i_l_d' [_l_o_g_i_c_a_l : _R_e_a_d] Whether the widget is part of a
          composite widget.  Default value: FALSE


     '_e_v_e_n_t_s' ['_G_d_k_E_v_e_n_t_M_a_s_k' : _R_e_a_d / _W_r_i_t_e] The event mask that
          decides what kind of GdkEvents this widget gets.  Default
          value: GDK_STRUCTURE_MASK


     '_e_x_t_e_n_s_i_o_n-_e_v_e_n_t_s' ['_G_d_k_E_x_t_e_n_s_i_o_n_M_o_d_e' : _R_e_a_d / _W_r_i_t_e] The mask
          that decides what kind of extension events this widget gets. 
          Default value: GDK_EXTENSION_EVENTS_NONE


     '_h_a_s-_d_e_f_a_u_l_t' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget is the
          default widget.  Default value: FALSE


     '_h_a_s-_f_o_c_u_s' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget has the
          input focus.  Default value: FALSE


     '_h_a_s-_t_o_o_l_t_i_p' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Enables or disables the
          emission of '"query-tooltip"' on 'widget'.   A value of
          'TRUE' indicates that 'widget' can have a tooltip, in this
          case the widget will be queried using '"query-tooltip"' to
          determine whether it will provide a tooltip or not.

          Note that setting this property to 'TRUE' for the first time
          will change the event masks of the GdkWindows of this widget
          to include leave-notify and motion-notify events.  This
          cannot and will not be undone when the property is set to
          'FALSE' again.  

          Default value: FALSE  Since  2.12


     '_h_e_i_g_h_t-_r_e_q_u_e_s_t' [_i_n_t_e_g_e_r : _R_e_a_d / _W_r_i_t_e] Override for height
          request of the widget, or -1 if natural request should be
          used.  Allowed values: >= -1  Default value: -1


     '_i_s-_f_o_c_u_s' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget is the
          focus widget within the toplevel.  Default value: FALSE


     '_n_a_m_e' [_c_h_a_r_a_c_t_e_r : _R_e_a_d / _W_r_i_t_e] The name of the widget.  Default
          value: NULL


     '_n_o-_s_h_o_w-_a_l_l' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether
          gtk_widget_show_all() should not affect this widget.  Default
          value: FALSE


     '_p_a_r_e_n_t' ['_G_t_k_C_o_n_t_a_i_n_e_r' : _R_e_a_d / _W_r_i_t_e] The parent widget of this
          widget. Must be a Container widget.


     '_r_e_c_e_i_v_e_s-_d_e_f_a_u_l_t' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] If TRUE, the widget
          will receive the default action when it is focused.  Default
          value: FALSE


     '_s_e_n_s_i_t_i_v_e' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget responds
          to input.  Default value: TRUE


     '_s_t_y_l_e' ['_G_t_k_S_t_y_l_e' : _R_e_a_d / _W_r_i_t_e] The style of the widget, which
          contains information about how it will look (colors etc).


     '_t_o_o_l_t_i_p-_m_a_r_k_u_p' [_c_h_a_r_a_c_t_e_r : _R_e_a_d / _W_r_i_t_e] Sets the text of
          tooltip to be the given string, which is marked up with the
          Pango text markup language. Also see 'gtkTooltipSetMarkup'.

          This is a convenience property which will take care of
          getting the tooltip shown if the given string is not 'NULL':
          '"has-tooltip"' will automatically be set to 'TRUE' and there
          will be taken care of '"query-tooltip"' in the default signal
          handler.  

          Default value: NULL  Since  2.12


     '_t_o_o_l_t_i_p-_t_e_x_t' [_c_h_a_r_a_c_t_e_r : _R_e_a_d / _W_r_i_t_e] Sets the text of tooltip
          to be the given string.

          Also see 'gtkTooltipSetText'.

          This is a convenience property which will take care of
          getting the tooltip shown if the given string is not 'NULL':
          '"has-tooltip"' will automatically be set to 'TRUE' and there
          will be taken care of '"query-tooltip"' in the default signal
          handler.  

          Default value: NULL  Since  2.12


     '_v_i_s_i_b_l_e' [_l_o_g_i_c_a_l : _R_e_a_d / _W_r_i_t_e] Whether the widget is visible. 
          Default value: FALSE


     '_w_i_d_t_h-_r_e_q_u_e_s_t' [_i_n_t_e_g_e_r : _R_e_a_d / _W_r_i_t_e] Override for width
          request of the widget, or -1 if natural request should be
          used.  Allowed values: >= -1  Default value: -1


_S_t_y_l_e _P_r_o_p_e_r_t_i_e_s:


     '_c_u_r_s_o_r-_a_s_p_e_c_t-_r_a_t_i_o' [_n_u_m_e_r_i_c : _R_e_a_d] Aspect ratio with which to
          draw insertion cursor.  Allowed values: [0,1]  Default value:
          0.04


     '_c_u_r_s_o_r-_c_o_l_o_r' ['_G_d_k_C_o_l_o_r' : _R_e_a_d] Color with which to draw
          insertion cursor.


     '_d_r_a_w-_b_o_r_d_e_r' ['_G_t_k_B_o_r_d_e_r' : _R_e_a_d] The "draw-border" style
          property defines the size of areas outside  the widget's
          allocation to draw.  

          Since  2.8


     '_f_o_c_u_s-_l_i_n_e-_p_a_t_t_e_r_n' [_c_h_a_r_a_c_t_e_r : _R_e_a_d] Dash pattern used to draw
          the focus indicator.  Default value: "\001\001"


     '_f_o_c_u_s-_l_i_n_e-_w_i_d_t_h' [_i_n_t_e_g_e_r : _R_e_a_d] Width, in pixels, of the focus
          indicator line.  Allowed values: >= 0  Default value: 1


     '_f_o_c_u_s-_p_a_d_d_i_n_g' [_i_n_t_e_g_e_r : _R_e_a_d] Width, in pixels, between focus
          indicator and the widget 'box'.  Allowed values: >= 0 
          Default value: 1


     '_i_n_t_e_r_i_o_r-_f_o_c_u_s' [_l_o_g_i_c_a_l : _R_e_a_d] Whether to draw the focus
          indicator inside widgets.  Default value: TRUE


     '_l_i_n_k-_c_o_l_o_r' ['_G_d_k_C_o_l_o_r' : _R_e_a_d] The "link-color" style property
          defines the color of unvisited links.  

          Since  2.10


     '_s_c_r_o_l_l-_a_r_r_o_w-_h_l_e_n_g_t_h' [_i_n_t_e_g_e_r : _R_e_a_d] The "scroll-arrow-hlength"
          style property defines the length of  horizontal scroll
          arrows.  

          Allowed values: >= 1  Default value: 16  Since  2.10


     '_s_c_r_o_l_l-_a_r_r_o_w-_v_l_e_n_g_t_h' [_i_n_t_e_g_e_r : _R_e_a_d] The "scroll-arrow-vlength"
          style property defines the length of  vertical scroll arrows.            

          Allowed values: >= 1  Default value: 16  Since  2.10


     '_s_e_c_o_n_d_a_r_y-_c_u_r_s_o_r-_c_o_l_o_r' ['_G_d_k_C_o_l_o_r' : _R_e_a_d] Color with which to
          draw the secondary insertion cursor when editing mixed
          right-to-left and left-to-right text.


     '_s_e_p_a_r_a_t_o_r-_h_e_i_g_h_t' [_i_n_t_e_g_e_r : _R_e_a_d] The "separator-height" style
          property defines the height of separators. This property only
          takes effect if '"wide-separators"' is 'TRUE'.  

          Allowed values: >= 0  Default value: 0  Since  2.10


     '_s_e_p_a_r_a_t_o_r-_w_i_d_t_h' [_i_n_t_e_g_e_r : _R_e_a_d] The "separator-width" style
          property defines the width of separators. This property only
          takes effect if '"wide-separators"' is 'TRUE'.  

          Allowed values: >= 0  Default value: 0  Since  2.10


     '_v_i_s_i_t_e_d-_l_i_n_k-_c_o_l_o_r' ['_G_d_k_C_o_l_o_r' : _R_e_a_d] The "visited-link-color"
          style property defines the color of visited links.  

          Since  2.10


     '_w_i_d_e-_s_e_p_a_r_a_t_o_r_s' [_l_o_g_i_c_a_l : _R_e_a_d] The "wide-separators" style
          property defines whether separators have  configurable width
          and should be drawn using a box instead of a line.  

          Default value: FALSE  Since  2.10


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

