GtkWidget {RGtk2}R Documentation

GtkWidget

Description

Base class for all widgets

Methods and Functions

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)
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)
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)
gtkRequisitionCopy(object)
gtkWidget(type, ..., show = TRUE)

Hierarchy

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

Interfaces

GtkWidget implements AtkImplementorIface.

Interface Derivations

GtkWidget is required by GtkFileChooser and GtkCellEditable.

Detailed Description

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 gtk\Widget\Style\Get\Valist() to obtain the value of a style property.

Structures

GtkWidget

style
[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.
requisition
[GtkRequisition] The widget's desired size.
allocation
[GtkAllocation] The widget's allocated size.
window
[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).
parent
[GtkWidget]

GtkWidgetClass
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.

GtkRequisition
A GtkRequisition represents the desired size of a widget. See for more information.

width
[integer] the widget's desired width
height
[integer] the widget's desired height

GtkSelectionData
undocumented

Convenient Construction

gtkWidget is the equivalent of gtkWidgetNew.

Enums and Flags

GtkWidgetFlags
Tells about certain properties of the widget.

toplevel
widgets without a real parent, as there are GtkWindows and GtkMenus have this flag set throughout their lifetime. Toplevel widgets always contain their own GdkWindow.
no-window
Indicative for a widget that does not provide its own GdkWindow. Visible action (e.g. drawing) is performed on the parent's GdkWindow.
realized
Set by gtkWidgetRealize, unset by gtkWidgetUnrealize. A realized widget has an associated GdkWindow.
mapped
Set by gtkWidgetMap, unset by gtkWidgetUnmap. Only realized widgets can be mapped. It means that gdkWindowShow has been called on the widgets window(s).
visible
Set by gtkWidgetShow, unset by gtkWidgetHide. Implies that a widget will be mapped as soon as its parent is mapped.
sensitive
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.
parent-sensitive
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.
can-focus
Determines whether a widget is able to handle focus grabs.
has-focus
Set by gtkWidgetGrabFocus for widgets that also have GTK_CAN_FOCUS set. The flag will be unset once another widget grabs the focus.
can-default
The widget is allowed to receive the default action via gtkWidgetGrabDefault.
has-default
The widget currently is receiving the default action.
has-grab
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.
rc-style
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.
composite-child
Indicates that the widget is a composite child of its parent; see gtkWidgetPushCompositeChild, gtkWidgetPopCompositeChild.
no-reparent
Unused since before GTK+ 1.2, will be removed in a future version.
app-paintable
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.
receives-default
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.
double-buffered
Set and unset by gtkWidgetSetDoubleBuffered. Indicates that exposes done on the widget should be double-buffered.
no-show-all
undocumented

GtkWidgetHelpType

tooltip
undocumented
whats-this
undocumented

GtkTextDirection

none
undocumented
ltr
undocumented
rtl
undocumented

User Functions

GtkCallback(widget, data)
The type of the callback functions used for e.g. iterating over the children of a container, see gtkContainerForeach.

widget
[GtkWidget] the widget to operate on
data
[R object] user-supplied data

Signals

accel-closures-changed(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

button-press-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventButton]
user.data
[R object] user data set when the signal handler was connected.

button-release-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventButton]
user.data
[R object] user data set when the signal handler was connected.

can-activate-accel(widget, signal.id, returns, user.data)
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.

widget
[GtkWidget] the object which received the signal
signal.id
[numeric] the ID of a signal installed on widget
returns
[R object] TRUE if the signal can be activated.
user.data
user data set when the signal handler was connected.

child-notify(widget, pspec, user.data)
The ::child-notify signal is emitted for each child property that has changed on an object. The signal's detail holds the property name.

widget
[GtkWidget] the object which received the signal.
pspec
[GParamSpec] the GParamSpec of the changed child property.
user.data
[R object] user data set when the signal handler was connected.

client-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventClient]
user.data
[R object] user data set when the signal handler was connected.

configure-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventConfigure]
user.data
[R object] user data set when the signal handler was connected.

delete-event(widget, event, user.data)
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.

widget
[GtkWidget] the object which received the signal.
event
[GdkEvent] the event which triggered this signal
user.data
[R object] user data set when the signal handler was connected.

destroy-event(widget, event, user.data)
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.

widget
[GtkWidget] the object which received the signal.
event
[GdkEvent] the event which triggered this signal
user.data
[R object] user data set when the signal handler was connected.

direction-changed(widget, arg1, user.data)

widget
[GtkWidget] the object which received the signal.
arg1
[GtkTextDirection]
user.data
[R object] user data set when the signal handler was connected.

drag-begin(widget, drag.context, user.data)
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.

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
user.data
[R object] user data set when the signal handler was connected.

drag-data-delete(widget, drag.context, user.data)
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.

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
user.data
[R object] user data set when the signal handler was connected.

drag-data-get(widget, drag.context, data, info, time, user.data)
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.

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
data
[GtkSelectionData] the GtkSelectionData to be filled with the dragged data
info
[numeric] the info that has been registered with the target in the GtkTargetList.
time
[numeric] the timestamp at which the data was requested
user.data
[R object] user data set when the signal handler was connected.

drag-data-received(widget, drag.context, x, y, data, info, time, user.data)
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)
}

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
x
[integer] where the drop happened
y
[integer] where the drop happened
data
[GtkSelectionData] the received data
info
[numeric] the info that has been registered with the target in the GtkTargetList.
time
[numeric] the timestamp at which the data was received
user.data
[R object] user data set when the signal handler was connected.

drag-drop(widget, drag.context, x, y, time, returns, user.data)
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 gtk\Drop\Get\Data() to receive the data for one or more of the supported targets.

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
x
[integer] the x coordinate of the current cursor position
y
[integer] the y coordinate of the current cursor position
time
[numeric] the timestamp of the motion event
returns
[R object] whether the cursor position is in a drop zone
user.data
user data set when the signal handler was connected.

drag-end(widget, drag.context, user.data)
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.

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
user.data
[R object] user data set when the signal handler was connected.

drag-leave(widget, drag.context, time, user.data)
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

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
time
[numeric] the timestamp of the motion event
user.data
[R object] user data set when the signal handler was connected.

drag-motion(widget, drag.context, x, y, time, returns, user.data)
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)
}

widget
[GtkWidget] the object which received the signal.
drag.context
[GdkDragContext] the drag context
x
[integer] the x coordinate of the current cursor position
y
[integer] the y coordinate of the current cursor position
time
[numeric] the timestamp of the motion event
returns
[R object] whether the cursor position is in a drop zone
user.data
user data set when the signal handler was connected.

enter-notify-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventCrossing]
user.data
[R object] user data set when the signal handler was connected.

event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEvent]
user.data
[R object] user data set when the signal handler was connected.

event-after(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEvent]
user.data
[R object] user data set when the signal handler was connected.

expose-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventExpose]
user.data
[R object] user data set when the signal handler was connected.

focus(widget, arg1, user.data)

widget
[GtkWidget] the object which received the signal.
arg1
[GtkDirectionType]
user.data
[R object] user data set when the signal handler was connected.

focus-in-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventFocus]
user.data
[R object] user data set when the signal handler was connected.

focus-out-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventFocus]
user.data
[R object] user data set when the signal handler was connected.

grab-broken-event(widget, event, user.data)
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

widget
[GtkWidget] the object which received the signal
event
[GdkEvent] the GdkEventGrabBroken event
user.data
[R object] user data set when the signal handler was connected.

grab-focus(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

grab-notify(widget, arg1, user.data)

widget
[GtkWidget] the object which received the signal.
arg1
[logical]
user.data
[R object] user data set when the signal handler was connected.

hide(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

hierarchy-changed(widget, widget2, user.data)
Emitted when there is a chance in the hierarchy to which a widget belong. More precisely, 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.

widget
[GtkWidget] the object which received the signal.
widget2
[GtkWidget]
user.data
[R object] user data set when the signal handler was connected.

key-press-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventKey]
user.data
[R object] user data set when the signal handler was connected.

key-release-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventKey]
user.data
[R object] user data set when the signal handler was connected.

leave-notify-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventCrossing]
user.data
[R object] user data set when the signal handler was connected.

map(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

map-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEvent]
user.data
[R object] user data set when the signal handler was connected.

mnemonic-activate(widget, arg1, user.data)

widget
[GtkWidget] the object which received the signal.
arg1
[logical]
user.data
[R object] user data set when the signal handler was connected.

motion-notify-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventMotion]
user.data
[R object] user data set when the signal handler was connected.

no-expose-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventNoExpose]
user.data
[R object] user data set when the signal handler was connected.

parent-set(widget, old.parent, user.data)

widget
[GtkWidget] the object which received the signal.
old.parent
[GtkObject]
user.data
[R object] user data set when the signal handler was connected.

popup-menu(widget, returns, user.data)
This signal gets emitted whenever a widget should pop up a context-sensitive 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.

widget
[GtkWidget] the object which received the signal
returns
[R object] TRUE if a menu was activated
user.data
user data set when the signal handler was connected.

property-notify-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventProperty]
user.data
[R object] user data set when the signal handler was connected.

proximity-in-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventProximity]
user.data
[R object] user data set when the signal handler was connected.

proximity-out-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventProximity]
user.data
[R object] user data set when the signal handler was connected.

realize(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

screen-changed(widget, arg1, user.data)

widget
[GtkWidget] the object which received the signal.
arg1
[GdkScreen]
user.data
[R object] user data set when the signal handler was connected.

scroll-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventScroll]
user.data
[R object] user data set when the signal handler was connected.

selection-clear-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventSelection]
user.data
[R object] user data set when the signal handler was connected.

selection-get(widget, data, info, time, user.data)

widget
[GtkWidget] the object which received the signal.
data
[GtkSelectionData]
info
[numeric]
time
[numeric]
user.data
[R object] user data set when the signal handler was connected.

selection-notify-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventSelection]
user.data
[R object] user data set when the signal handler was connected.

selection-received(widget, data, time, user.data)

widget
[GtkWidget] the object which received the signal.
data
[GtkSelectionData]
time
[numeric]
user.data
[R object] user data set when the signal handler was connected.

selection-request-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventSelection]
user.data
[R object] user data set when the signal handler was connected.

show(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

show-help(widget, arg1, user.data)

widget
[GtkWidget] the object which received the signal.
arg1
[GtkWidgetHelpType]
user.data
[R object] user data set when the signal handler was connected.

size-allocate(widget, allocation, user.data)

widget
[GtkWidget] the object which received the signal.
allocation
[GtkAllocation]
user.data
[R object] user data set when the signal handler was connected.

size-request(widget, requisition, user.data)

widget
[GtkWidget] the object which received the signal.
requisition
[GtkRequisition]
user.data
[R object] user data set when the signal handler was connected.

state-changed(widget, state, user.data)

widget
[GtkWidget] the object which received the signal.
state
[GtkStateType]
user.data
[R object] user data set when the signal handler was connected.

style-set(widget, previous.style, user.data)
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.

widget
[GtkWidget] the object on which the signal is emitted
previous.style
[GtkStyle] the previous style, or NULL if the widget just got its initial style
user.data
[R object] user data set when the signal handler was connected.

unmap(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

unmap-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEvent]
user.data
[R object] user data set when the signal handler was connected.

unrealize(widget, user.data)

widget
[GtkWidget] the object which received the signal.
user.data
[R object] user data set when the signal handler was connected.

visibility-notify-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventVisibility]
user.data
[R object] user data set when the signal handler was connected.

window-state-event(widget, event, user.data)

widget
[GtkWidget] the object which received the signal.
event
[GdkEventWindowState]
user.data
[R object] user data set when the signal handler was connected.

Properties

app-paintable [logical : Read / Write]

Whether the application will paint directly on the widget. Default value: FALSE

can-default [logical : Read / Write]

Whether the widget can be the default widget. Default value: FALSE

can-focus [logical : Read / Write]

Whether the widget can accept the input focus. Default value: FALSE

composite-child [logical : Read]

Whether the widget is part of a composite widget. Default value: FALSE

events [GdkEventMask : Read / Write]

The event mask that decides what kind of GdkEvents this widget gets. Default value: GDK_STRUCTURE_MASK

extension-events [GdkExtensionMode : Read / Write]

The mask that decides what kind of extension events this widget gets. Default value: GDK_EXTENSION_EVENTS_NONE

has-default [logical : Read / Write]

Whether the widget is the default widget. Default value: FALSE

has-focus [logical : Read / Write]

Whether the widget has the input focus. Default value: FALSE

height-request [integer : Read / Write]

Override for height request of the widget, or -1 if natural request should be used. Allowed values: >= -1 Default value: -1

is-focus [logical : Read / Write]

Whether the widget is the focus widget within the toplevel. Default value: FALSE

name [character : Read / Write]

The name of the widget. Default value: NULL

no-show-all [logical : Read / Write]

Whether gtk_widget_show_all() should not affect this widget. Default value: FALSE

parent [GtkContainer : Read / Write]

The parent widget of this widget. Must be a Container widget.

receives-default [logical : Read / Write]

If TRUE, the widget will receive the default action when it is focused. Default value: FALSE

sensitive [logical : Read / Write]

Whether the widget responds to input. Default value: TRUE

style [GtkStyle : Read / Write]

The style of the widget, which contains information about how it will look (colors etc).

visible [logical : Read / Write]

Whether the widget is visible. Default value: FALSE

width-request [integer : Read / Write]

Override for width request of the widget, or -1 if natural request should be used. Allowed values: >= -1 Default value: -1

Style Properties

cursor-aspect-ratio [numeric : Read]

Aspect ratio with which to draw insertion cursor. Allowed values: [0,1] Default value: 0.04

cursor-color [GdkColor : Read]

Color with which to draw insertion cursor.

draw-border [GtkBorder : Read]

Size of areas outside the widget's allocation to draw.

focus-line-pattern [character : Read]

Dash pattern used to draw the focus indicator. Default value: "\001\001"

focus-line-width [integer : Read]

Width, in pixels, of the focus indicator line. Allowed values: >= 0 Default value: 1

focus-padding [integer : Read]

Width, in pixels, between focus indicator and the widget 'box'. Allowed values: >= 0 Default value: 1

interior-focus [logical : Read]

Whether to draw the focus indicator inside widgets. Default value: TRUE

secondary-cursor-color [GdkColor : Read]

Color with which to draw the secondary insertion cursor when editing mixed right-to-left and left-to-right text.

Author(s)

Derived by RGtkGen from GTK+ documentation

References

http://developer.gnome.org/doc/API/2.0/gtk/GtkWidget.html


[Package RGtk2 version 2.8.6 Index]