This is guile-gnome-gtk.info, produced by makeinfo version 4.8 from
guile-gnome-gtk.texi.

   This manual is for `(gnome gtk)' (version 2.15.93, updated 2
September 2007)

   Copyright 1997-2007 Damon Chaplin and others

     This work may be reproduced and distributed in whole or in part, in
     any medium, physical or electronic, so as long as this copyright
     notice remains intact and unchanged on all copies.  Commercial
     redistribution is permitted and encouraged, but you may not
     redistribute, in whole or in part, under terms more restrictive
     than those under which you received it. If you redistribute a
     modified or translated version of this work, you must also make
     the source code to the modified or translated version available in
     electronic form without charge.  However, mere aggregation as part
     of a larger work shall not count as a modification for this
     purpose.

     All code examples in this work are placed into the public domain,
     and may be used, modified and redistributed without restriction.

     BECAUSE THIS WORK IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
     FOR THE WORK, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT
     WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
     OTHER PARTIES PROVIDE THE WORK "AS IS" WITHOUT WARRANTY OF ANY
     KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
     THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
     PARTICULAR PURPOSE.  SHOULD THE WORK PROVE DEFECTIVE, YOU ASSUME
     THE COST OF ALL NECESSARY REPAIR OR CORRECTION.

     IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
     WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
     MODIFY AND/OR REDISTRIBUTE THE WORK AS PERMITTED ABOVE, BE LIABLE
     TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
     CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
     THE WORK, EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF
     THE POSSIBILITY OF SUCH DAMAGES.

INFO-DIR-SECTION The Algorithmic Language Scheme
START-INFO-DIR-ENTRY
* Guile-Gtk: (guile-gnome-gtk.info).  The GIMP ToolKit.
END-INFO-DIR-ENTRY


File: guile-gnome-gtk.info,  Node: GtkPrintUnixDialog,  Next: GtkPageSetupUnixDialog,  Prev: GtkPrintJob,  Up: Top

116 GtkPrintUnixDialog
**********************

A print dialog

116.1 Overview
==============

GtkPrintUnixDialog implements a print dialog for platforms which don't
provide a native print dialog, like Unix. It can be used very much like
any other GTK+ dialog, at the cost of the portability offered by the
high-level printing API

   In order to print something with `<gtk-print-unix-dialog>', you need
to use `gtk-print-unix-dialog-get-selected-printer' to obtain a
`<gtk-printer>' object and use it to construct a `<gtk-print-job>'
using `gtk-print-job-new'.

   `<gtk-print-unix-dialog>' uses the following response values:

GTK_RESPONSE_APPLY

GTK_RESPONSE_CANCEL

   for the "Print" button

   for the "Preview" button

   for the "Cancel" button

   Printing support was added in GTK+ 2.10.

116.2 Usage
===========


File: guile-gnome-gtk.info,  Node: GtkPageSetupUnixDialog,  Next: GtkAdjustment,  Prev: GtkPrintUnixDialog,  Up: Top

117 GtkPageSetupUnixDialog
**************************

A page setup dialog

117.1 Overview
==============

GtkPageSetupUnixDialog implements a page setup dialog for platforms
which don't provide a native page setup dialog, like Unix. It can be
used very much like any other GTK+ dialog, at the cost of the
portability offered by the high-level printing API

   Printing support was added in GTK+ 2.10.

117.2 Usage
===========


File: guile-gnome-gtk.info,  Node: GtkAdjustment,  Next: GtkArrow,  Prev: GtkPageSetupUnixDialog,  Up: Top

118 GtkAdjustment
*****************

A GtkObject representing an adjustable bounded value

118.1 Overview
==============

The `<gtk-adjustment>' object represents a value which has an associated
lower and upper bound, together with step and page increments, and a
page size.  It is used within several GTK+ widgets, including
`<gtk-spin-button>', `<gtk-viewport>', and `<gtk-range>' (which is a
base class for `<gtk-hscrollbar>', `<gtk-vscrollbar>', `<gtk-hscale>',
and `<gtk-vscale>').

   The `<gtk-adjustment>' object does not update the value itself.
Instead it is left up to the owner of the `<gtk-adjustment>' to control
the value.

   The owner of the `<gtk-adjustment>' typically calls the
`gtk-adjustment-value-changed' and `gtk-adjustment-changed' functions
after changing the value and its bounds. This results in the emission
of the "value_changed" or "changed" signal respectively.

118.2 Usage
===========

 -- Class: <gtk-adjustment>
     Derives from `<gtk-object>'.

     This class defines the following properties:

    `value'
          The value of the adjustment

    `lower'
          The minimum value of the adjustment

    `upper'
          The maximum value of the adjustment

    `step-increment'
          The step increment of the adjustment

    `page-increment'
          The page increment of the adjustment

    `page-size'
          The page size of the adjustment



 -- Signal on <gtk-adjustment>: changed
     Emitted when one or more of the `<gtk-adjustment>' fields have been
     changed, other than the value field.


 -- Signal on <gtk-adjustment>: value-changed
     Emitted when the `<gtk-adjustment>' value field has been changed.


 -- Function: gtk-adjustment-new (value `double') (lower `double')
          (upper `double') (step_increment `double')
          (page_increment `double') (page_size `double') => 
          (ret `<gtk-object>')
     Creates a new `<gtk-adjustment>'.

    VALUE
          the initial value.

    LOWER
          the minimum value.

    UPPER
          the maximum value.

    STEP-INCREMENT
          the step increment.

    PAGE-INCREMENT
          the page increment.

    PAGE-SIZE
          the page size.

    RET
          a new `<gtk-adjustment>'.



 -- Function: gtk-adjustment-get-value (self `<gtk-adjustment>') => 
          (ret `double')
 -- Method: get-value
     Gets the current value of the adjustment. See
     `gtk-adjustment-set-value'.

    ADJUSTMENT
          a `<gtk-adjustment>'

    RET
          The current value of the adjustment.



 -- Function: gtk-adjustment-set-value (self `<gtk-adjustment>')
          (value `double')
 -- Method: set-value
     Sets the `<gtk-adjustment>' value. The value is clamped to lie
     between `adjustment->lower' and `adjustment->upper'.

     Note that for adjustments which are used in a `<gtk-scrollbar>',
     the effective range of allowed values goes from
     `adjustment->lower' to `adjustment->upper - adjustment->page_size'.

    ADJUSTMENT
          a `<gtk-adjustment>'.

    VALUE
          the new value.



 -- Function: gtk-adjustment-clamp-page (self `<gtk-adjustment>')
          (lower `double') (upper `double')
 -- Method: clamp-page
     Updates the `<gtk-adjustment>'VALUE to ensure that the range
     between LOWER and UPPER is in the current page (i.e. between VALUE
     and VALUE + PAGE-SIZE). If the range is larger than the page size,
     then only the start of it will be in the current page. A "changed"
     signal will be emitted if the value is changed.

    ADJUSTMENT
          a `<gtk-adjustment>'.

    LOWER
          the lower value.

    UPPER
          the upper value.



 -- Function: gtk-adjustment-changed (self `<gtk-adjustment>')
 -- Method: changed
     Emits a "changed" signal from the `<gtk-adjustment>'. This is
     typically called by the owner of the `<gtk-adjustment>' after it
     has changed any of the `<gtk-adjustment>' fields other than the
     value.

    ADJUSTMENT
          a `<gtk-adjustment>'



 -- Function: gtk-adjustment-value-changed (self `<gtk-adjustment>')
 -- Method: value-changed
     Emits a "value_changed" signal from the `<gtk-adjustment>'. This is
     typically called by the owner of the `<gtk-adjustment>' after it
     has changed the `<gtk-adjustment>' value field.

    ADJUSTMENT
          a `<gtk-adjustment>'




File: guile-gnome-gtk.info,  Node: GtkArrow,  Next: GtkCalendar,  Prev: GtkAdjustment,  Up: Top

119 GtkArrow
************

Displays an arrow

119.1 Overview
==============

GtkArrow should be used to draw simple arrows that need to point in one
of the four cardinal directions (up, down, left, or right). The style
of the arrow can be one of shadow in, shadow out, etched in, or etched
out. Note that these directions and style types may be ammended in
versions of Gtk to come.

   GtkArrow will fill any space alloted to it, but since it is
inherited from `<gtk-misc>', it can be padded and/or aligned, to fill
exactly the space the programmer desires.

   Arrows are created with a call to `gtk-arrow-new'. The direction or
style of an arrow can be changed after creation by using
`gtk-arrow-set'.

119.2 Usage
===========

 -- Class: <gtk-arrow>
     Derives from `<gtk-misc>'.

     This class defines the following properties:

    `arrow-type'
          The direction the arrow should point

    `shadow-type'
          Appearance of the shadow surrounding the arrow



 -- Function: gtk-arrow-new (arrow_type `<gtk-arrow-type>')
          (shadow_type `<gtk-shadow-type>') =>  (ret `<gtk-widget>')
     Creates a new arrow widget.

    ARROW-TYPE
          a valid `<gtk-arrow-type>'.

    SHADOW-TYPE
          a valid `<gtk-shadow-type>'.

    RET
          the new `<gtk-arrow>' widget.



 -- Function: gtk-arrow-set (self `<gtk-arrow>')
          (arrow_type `<gtk-arrow-type>')
          (shadow_type `<gtk-shadow-type>')
 -- Method: set
     Sets the direction and style of the `<gtk-arrow>', ARROW.

    ARROW
          a widget of type `<gtk-arrow>'.

    ARROW-TYPE
          a valid `<gtk-arrow-type>'.

    SHADOW-TYPE
          a valid `<gtk-shadow-type>'.




File: guile-gnome-gtk.info,  Node: GtkCalendar,  Next: GtkDrawingArea,  Prev: GtkArrow,  Up: Top

120 GtkCalendar
***************

Displays a calendar and allows the user to select a date

120.1 Overview
==============

`<gtk-calendar>' is a widget that displays a calendar, one month at a
time.  It can be created with `gtk-calendar-new'.

   The month and year currently displayed can be altered with
`gtk-calendar-select-month'. The exact day can be selected from the
displayed month using `gtk-calendar-select-day'.

   To place a visual marker on a particular day, use
`gtk-calendar-mark-day' and to remove the marker,
`gtk-calendar-unmark-day'. Alternative, all marks can be cleared with
`gtk-calendar-clear-marks'.

   The way in which the calendar itself is displayed can be altered
using `gtk-calendar-set-display-options'.

   The selected date can be retrieved from a `<gtk-calendar>' using
`gtk-calendar-get-date'.

120.2 Usage
===========

 -- Class: <gtk-calendar>
     Derives from `<gtk-widget>'.

     This class defines the following properties:

    `year'
          The selected year

    `month'
          The selected month (as a number between 0 and 11)

    `day'
          The selected day (as a number between 1 and 31, or 0 to
          unselect the currently selected day)

    `show-heading'
          If TRUE, a heading is displayed

    `show-day-names'
          If TRUE, day names are displayed

    `no-month-change'
          If TRUE, the selected month cannot be changed

    `show-week-numbers'
          If TRUE, week numbers are displayed



 -- Signal on <gtk-calendar>: month-changed
     Emitted when the user clicks a button to change the selected month
     on a calendar.


 -- Signal on <gtk-calendar>: day-selected
     Emitted when the user selects a day.


 -- Signal on <gtk-calendar>: day-selected-double-click

 -- Signal on <gtk-calendar>: prev-month

 -- Signal on <gtk-calendar>: next-month

 -- Signal on <gtk-calendar>: prev-year

 -- Signal on <gtk-calendar>: next-year

 -- Function: gtk-calendar-new =>  (ret `<gtk-widget>')
     Creates a new calendar, with the current date being selected.

    RET
          a newly `<gtk-calendar>' widget



 -- Function: gtk-calendar-select-month (self `<gtk-calendar>')
          (month `unsigned-int') (year `unsigned-int') =>  (ret `bool')
 -- Method: select-month
     Shifts the calendar to a different month.

    CALENDAR
          a `<gtk-calendar>'

    MONTH
          a month number between 0 and 11.

    YEAR
          the year the month is in.

    RET
          ``#t'', always



 -- Function: gtk-calendar-select-day (self `<gtk-calendar>')
          (day `unsigned-int')
 -- Method: select-day
     Selects a day from the current month.

    CALENDAR
          a `<gtk-calendar>'.

    DAY
          the day number between 1 and 31, or 0 to unselect the
          currently selected day.



 -- Function: gtk-calendar-mark-day (self `<gtk-calendar>')
          (day `unsigned-int') =>  (ret `bool')
 -- Method: mark-day
     Places a visual marker on a particular day.

    CALENDAR
          a `<gtk-calendar>'

    DAY
          the day number to mark between 1 and 31.

    RET
          ``#t'', always



 -- Function: gtk-calendar-unmark-day (self `<gtk-calendar>')
          (day `unsigned-int') =>  (ret `bool')
 -- Method: unmark-day
     Removes the visual marker from a particular day.

    CALENDAR
          a `<gtk-calendar>'.

    DAY
          the day number to unmark between 1 and 31.

    RET
          ``#t'', always



 -- Function: gtk-calendar-clear-marks (self `<gtk-calendar>')
 -- Method: clear-marks
     Remove all visual markers.

    CALENDAR
          a `<gtk-calendar>'



 -- Function: gtk-calendar-set-display-options (self `<gtk-calendar>')
          (flags `<gtk-calendar-display-options>')
 -- Method: set-display-options
     Sets display options (whether to display the heading and the month
     headings).

    CALENDAR
          a `<gtk-calendar>'

    FLAGS
          the display options to set


     Since 2.4


 -- Function: gtk-calendar-get-date (self `<gtk-calendar>') => 
          (year `unsigned-int') (month `unsigned-int')
          (day `unsigned-int')
 -- Method: get-date
     Obtains the selected date from a `<gtk-calendar>'.

    CALENDAR
          a `<gtk-calendar>'

    YEAR
          location to store the year number, or ``#f''

    MONTH
          location to store the month number (between 0 and 11), or
          ``#f''

    DAY
          location to store the day number (between 1 and 31), or ``#f''



 -- Function: gtk-calendar-freeze (self `<gtk-calendar>')
 -- Method: freeze
     `gtk_calendar_freeze' has been deprecated since version 2.8 and
     should not be used in newly-written code.

     Does nothing. Previously locked the display of the calendar until
     it was thawed with `gtk-calendar-thaw'.

    CALENDAR
          a `<gtk-calendar>'



 -- Function: gtk-calendar-thaw (self `<gtk-calendar>')
 -- Method: thaw
     `gtk_calendar_thaw' has been deprecated since version 2.8 and
     should not be used in newly-written code.

     Does nothing. Previously defrosted a calendar; all the changes
     made since the last `gtk-calendar-freeze' were displayed.

    CALENDAR
          a `<gtk-calendar>'




File: guile-gnome-gtk.info,  Node: GtkDrawingArea,  Next: GtkEventBox,  Prev: GtkCalendar,  Up: Top

121 GtkDrawingArea
******************

A widget for custom user interface elements

121.1 Overview
==============

The `<gtk-drawing-area>' widget is used for creating custom user
interface elements. It's essentially a blank widget; you can draw on
`widget->window'. After creating a drawing area, the application may
want to connect to:

   Mouse and button press signals to respond to input from the user.
(Use `gtk-widget-add-events' to enable events you wish to receive.)

   The "realize" signal to take any necessary actions when the widget is
instantiated on a particular display. (Create GDK resources in response
to this signal.)

   The "configure_event" signal to take any necessary actions when the
widget changes size.

   The "expose_event" signal to handle redrawing the contents of the
widget.

   The following code portion demonstrates using a drawing area to
display a circle in the normal widget foreground color. Note that GDK
automatically clears the exposed area to the background color before
sending the expose event, and that drawing is implicitly clipped to the
exposed area.


     gboolean
     expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)
     {
       gdk_draw_arc (widget->window,
                     widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                     TRUE,
                     0, 0, widget->allocation.width, widget->allocation.height,
                     0, 64 * 360);

       return TRUE;
     }
     [...]
       GtkWidget *drawing_area = gtk_drawing_area_new ();
       gtk_widget_set_size_request (drawing_area, 100, 100);
       g_signal_connect (G_OBJECT (drawing_area), "expose_event",
                         G_CALLBACK (expose_event_callback), NULL);

   Expose events are normally delivered when a drawing area first comes
onscreen, or when it's covered by another window and then uncovered
(exposed). You can also force an expose event by adding to the "damage
region" of the drawing area's window; `gtk-widget-queue-draw-area' and
`gdk-window-invalidate-rect' are equally good ways to do this. You'll
then get an expose event for the invalid region.

   The available routines for drawing are documented on the GDK Drawing
Primitives page. See also `gdk-pixbuf-render-to-drawable' for drawing a
`<gdk-pixbuf>'.

   To receive mouse events on a drawing area, you will need to enable
them with `gtk-widget-add-events'. To receive keyboard events, you will
need to set the `<gtk-can-focus>' flag on the drawing area, and should
probably draw some user-visible indication that the drawing area is
focused. Use the `gtk-has-focus' macro in your expose event handler to
decide whether to draw the focus indicator. See `gtk-paint-focus' for
one way to draw focus.

121.2 Usage
===========

 -- Class: <gtk-drawing-area>
     Derives from `<gtk-widget>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-drawing-area-new =>  (ret `<gtk-widget>')
     Creates a new drawing area.

    RET
          a new `<gtk-drawing-area>'




File: guile-gnome-gtk.info,  Node: GtkEventBox,  Next: GtkHandleBox,  Prev: GtkDrawingArea,  Up: Top

122 GtkEventBox
***************

A widget used to catch events for widgets which do not have their own
window

122.1 Overview
==============

The `<gtk-event-box>' widget is a subclass of `<gtk-bin>' which also
has its own window. It is useful since it allows you to catch events
for widgets which do not have their own window.

122.2 Usage
===========

 -- Class: <gtk-event-box>
     Derives from `<gtk-bin>'.

     This class defines the following properties:

    `visible-window'
          Whether the event box is visible, as opposed to invisible and
          only used to trap events.

    `above-child'
          Whether the event-trapping window of the eventbox is above
          the window of the child widget as opposed to below it.



 -- Function: gtk-event-box-new =>  (ret `<gtk-widget>')
     Creates a new `<gtk-event-box>'.

    RET
          a new `<gtk-event-box>'.



 -- Function: gtk-event-box-set-above-child (self `<gtk-event-box>')
          (above_child `bool')
 -- Method: set-above-child
     Set whether the event box window is positioned above the windows
     of its child, as opposed to below it. If the window is above, all
     events inside the event box will go to the event box. If the
     window is below, events in windows of child widgets will first got
     to that widget, and then to its parents.

     The default is to keep the window below the child.

    EVENT-BOX
          a `<gtk-event-box>'

    ABOVE-CHILD
          ``#t'' if the event box window is above the windows of its
          child


     Since 2.4


 -- Function: gtk-event-box-get-above-child (self `<gtk-event-box>')
          =>  (ret `bool')
 -- Method: get-above-child
     Returns whether the event box window is above or below the windows
     of its child.  See `gtk-event-box-set-above-child' for details.

    EVENT-BOX
          a `<gtk-event-box>'

    RET
          ``#t'' if the event box window is above the window of its
          child.


     Since 2.4


 -- Function: gtk-event-box-set-visible-window (self `<gtk-event-box>')
          (visible_window `bool')
 -- Method: set-visible-window
     Set whether the event box uses a visible or invisible child
     window. The default is to use visible windows.

     In an invisible window event box, the window that that the event
     box creates is a `GDK_INPUT_ONLY' window, which means that it is
     invisible and only serves to receive events.

     A visible window event box creates a visible (`GDK_INPUT_OUTPUT')
     window that acts as the parent window for all the widgets
     contained in the event box.

     You should generally make your event box invisible if you just
     want to trap events. Creating a visible window may cause artifacts
     that are visible to the user, especially if the user is using a
     theme with gradients or pixmaps.

     The main reason to create a non input-only event box is if you
     want to set the background to a different color or draw on it.

     There is one unexpected issue for an invisible event box that has
     its window below the child. (See `gtk-event-box-set-above-child'.)
     Since the input-only window is not an ancestor window of any
     windows that descendent widgets of the event box create, events on
     these windows aren't propagated up by the windowing system, but
     only by GTK+. The practical effect of this is if an event isn't in
     the event mask for the descendant window (see
     `gtk-widget-add-events'), it won't be received by the event box.

     This problem doesn't occur for visible event boxes, because in
     that case, the event box window is actually the ancestor of the
     descendant windows, not just at the same place on the screen.

    EVENT-BOX
          a `<gtk-event-box>'

    VISIBLE-WINDOW
          boolean value


     Since 2.4


 -- Function: gtk-event-box-get-visible-window (self `<gtk-event-box>')
          =>  (ret `bool')
 -- Method: get-visible-window
     Returns whether the event box has a visible window. See
     `gtk-event-box-set-visible-window' for details.

    EVENT-BOX
          a `<gtk-event-box>'

    RET
          ``#t'' if the event box window is visible


     Since 2.4



File: guile-gnome-gtk.info,  Node: GtkHandleBox,  Next: GtkIMContextSimple,  Prev: GtkEventBox,  Up: Top

123 GtkHandleBox
****************

a widget for detachable window portions

123.1 Overview
==============

The `<gtk-handle-box>' widget allows a portion of a window to be "torn
off". It is a bin widget which displays its child and a handle that the
user can drag to tear off a separate window (the "float window")
containing the child widget. A thin "ghost" is drawn in the original
location of the handlebox.  By dragging the separate window back to its
original location, it can be reattached.

   When reattaching, the ghost and float window, must be aligned along
one of the edges, the "snap edge". This either can be specified by the
application programmer explicitely, or GTK+ will pick a reasonable
default based on the handle position.

   To make detaching and reattaching the handlebox as minimally
confusing as possible to the user, it is important to set the snap edge
so that the snap edge does not move when the handlebox is deattached.
For instance, if the handlebox is packed at the bottom of a VBox, then
when the handlebox is detached, the bottom edge of the handlebox's
allocation will remain fixed as the height of the handlebox shrinks, so
the snap edge should be set to `GTK_POS_BOTTOM'.

123.2 Usage
===========

 -- Class: <gtk-handle-box>
     Derives from `<gtk-bin>'.

     This class defines the following properties:

    `shadow'
          Deprecated property, use shadow_type instead

    `shadow-type'
          Appearance of the shadow that surrounds the container

    `handle-position'
          Position of the handle relative to the child widget

    `snap-edge'
          Side of the handlebox that's lined up with the docking point
          to dock the handlebox

    `snap-edge-set'
          Whether to use the value from the snap_edge property or a
          value derived from handle_position



 -- Signal on <gtk-handle-box>: child-attached (arg0 `<gtk-widget>')
     This signal is emitted when the contents of the handlebox are
     reattached to the main window.


 -- Signal on <gtk-handle-box>: child-detached (arg0 `<gtk-widget>')
     This signal is emitted when the contents of the handlebox are
     detached from the main window.


 -- Function: gtk-handle-box-new =>  (ret `<gtk-widget>')
     Create a new handle box.

    RET
          a new `<gtk-handle-box>'.



 -- Function: gtk-handle-box-set-shadow-type (self `<gtk-handle-box>')
          (type `<gtk-shadow-type>')
 -- Method: set-shadow-type
     Sets the type of shadow to be drawn around the border of the
     handle box.

    HANDLE-BOX
          a `<gtk-handle-box>'

    TYPE
          the shadow type.



 -- Function: gtk-handle-box-set-handle-position
          (self `<gtk-handle-box>') (position `<gtk-position-type>')
 -- Method: set-handle-position
     Sets the side of the handlebox where the handle is drawn.

    HANDLE-BOX
          a `<gtk-handle-box>'

    POSITION
          the side of the handlebox where the handle should be drawn.



 -- Function: gtk-handle-box-set-snap-edge (self `<gtk-handle-box>')
          (edge `<gtk-position-type>')
 -- Method: set-snap-edge
     Sets the snap edge of a handlebox. The snap edge is the edge of
     the detached child that must be aligned with the corresponding
     edge of the "ghost" left behind when the child was detached to
     reattach the torn-off window. Usually, the snap edge should be
     chosen so that it stays in the same place on the screen when the
     handlebox is torn off.

     If the snap edge is not set, then an appropriate value will be
     guessed from the handle position. If the handle position is
     `GTK_POS_RIGHT' or `GTK_POS_LEFT', then the snap edge will be
     `GTK_POS_TOP', otherwise it will be `GTK_POS_LEFT'.

    HANDLE-BOX
          a `<gtk-handle-box>'

    EDGE
          the snap edge, or -1 to unset the value; in which case GTK+
          will try to guess an appropriate value in the future.



 -- Function: gtk-handle-box-get-handle-position
          (self `<gtk-handle-box>') =>  (ret `<gtk-position-type>')
 -- Method: get-handle-position
     Gets the handle position of the handle box. See
     `gtk-handle-box-set-handle-position'.

    HANDLE-BOX
          a `<gtk-handle-box>'

    RET
          the current handle position.



 -- Function: gtk-handle-box-get-shadow-type (self `<gtk-handle-box>')
          =>  (ret `<gtk-shadow-type>')
 -- Method: get-shadow-type
     Gets the type of shadow drawn around the handle box. See
     `gtk-handle-box-set-shadow-type'.

    HANDLE-BOX
          a `<gtk-handle-box>'

    RET
          the type of shadow currently drawn around the handle box.



 -- Function: gtk-handle-box-get-snap-edge (self `<gtk-handle-box>')
          =>  (ret `<gtk-position-type>')
 -- Method: get-snap-edge
     Gets the edge used for determining reattachment of the handle box.
     See `gtk-handle-box-set-snap-edge'.

    HANDLE-BOX
          a `<gtk-handle-box>'

    RET
          the edge used for determining reattachment, or
          (GtkPositionType)-1 if this is determined (as per default)
          from the handle position.




File: guile-gnome-gtk.info,  Node: GtkIMContextSimple,  Next: GtkIMMulticontext,  Prev: GtkHandleBox,  Up: Top

124 GtkIMContextSimple
**********************

An input method context supporting table-based input methods

124.1 Overview
==============

124.2 Usage
===========

 -- Class: <gtk-im-context-simple>
     Derives from `<gtk-im-context>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-im-context-simple-new =>  (ret `<gtk-im-context>')
     Creates a new `<gtk-im-context-simple>'.

    RET
          a new `<gtk-im-context-simple>'.



 -- Function: gtk-im-context-simple-add-table
          (self `<gtk-im-context-simple>') (max_seq_len `int')
          (n_seqs `int') =>  (data `unsigned-int16')
 -- Method: add-table
     Adds an additional table to search to the input context. Each row
     of the table consists of MAX-SEQ-LEN key symbols followed by two
     `<guint16>' interpreted as the high and low words of a
     `<gunicode>' value. Tables are searched starting from the last
     added.

     The table must be sorted in dictionary order on the numeric value
     of the key symbol fields. (Values beyond the length of the
     sequence should be zero.)

    CONTEXT-SIMPLE
          A `<gtk-im-context-simple>'

    DATA
          the table

    MAX-SEQ-LEN
          Maximum length of a sequence in the table (cannot be greater
          than `<gtk-max-compose-len>')

    N-SEQS
          number of sequences in the table




File: guile-gnome-gtk.info,  Node: GtkIMMulticontext,  Next: GtkSizeGroup,  Prev: GtkIMContextSimple,  Up: Top

125 GtkIMMulticontext
*********************

An input method context supporting multiple, loadable input methods

125.1 Overview
==============

125.2 Usage
===========

 -- Class: <gtk-im-multicontext>
     Derives from `<gtk-im-context>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-im-multicontext-new =>  (ret `<gtk-im-context>')
     Creates a new `<gtk-im-multicontext>'.

    RET
          a new `<gtk-im-multicontext>'.




File: guile-gnome-gtk.info,  Node: GtkSizeGroup,  Next: GtkTooltips,  Prev: GtkIMMulticontext,  Up: Top

126 GtkSizeGroup
****************

Grouping widgets so they request the same size

126.1 Overview
==============

`<gtk-size-group>' provides a mechanism for grouping a number of widgets
together so they all request the same amount of space. This is
typically useful when you want a column of widgets to have the same
size, but you can't use a `<gtk-table>' widget.

   In detail, the size requested for each widget in a
`<gtk-size-group>' is the maximum of the sizes that would have been
requested for each widget in the size group if they were not in the
size group. The mode of the size group (see `gtk-size-group-set-mode')
determines whether this applies to the horizontal size, the vertical
size, or both sizes.

   Note that size groups only affect the amount of space requested, not
the size that the widgets finally receive. If you want the widgets in a
`<gtk-size-group>' to actually be the same size, you need to pack them
in such a way that they get the size they request and not more. For
example, if you are packing your widgets into a table, you would not
include the `GTK_FILL' flag.

   `<gtk-size-group>' objects are referenced by each widget in the size
group, so once you have added all widgets to a `<gtk-size-group>', you
can drop the initial reference to the size group with `g-object-unref'.
If the widgets in the size group are subsequently destroyed, then they
will be removed from the size group and drop their references on the
size group; when all widgets have been removed, the size group will be
freed.

   Widgets can be part of multiple size groups; GTK+ will compute the
horizontal size of a widget from the horizontal requisition of all
widgets that can be reached from the widget by a chain of size groups
of type `GTK_SIZE_GROUP_HORIZONTAL' or `GTK_SIZE_GROUP_BOTH', and the
vertical size from the vertical requisition of all widgets that can be
reached from the widget by a chain of size groups of type
`GTK_SIZE_GROUP_VERTICAL' or `GTK_SIZE_GROUP_BOTH'.

126.2 Usage
===========

 -- Class: <gtk-size-group>
     Derives from `<gtk-buildable>', `<gobject>'.

     This class defines the following properties:

    `mode'
          The directions in which the size group affects the requested
          sizes of its component widgets

    `ignore-hidden'
          If TRUE, unmapped widgets are ignored when determining the
          size of the group



 -- Function: gtk-size-group-new (mode `<gtk-size-group-mode>') => 
          (ret `<gtk-size-group>')
     Create a new `<gtk-size-group>'.

    MODE
          the mode for the new size group.

    RET
          a newly created `<gtk-size-group>'



 -- Function: gtk-size-group-set-mode (self `<gtk-size-group>')
          (mode `<gtk-size-group-mode>')
 -- Method: set-mode
     Sets the `<gtk-size-group-mode>' of the size group. The mode of
     the size group determines whether the widgets in the size group
     should all have the same horizontal requisition
     (`GTK_SIZE_GROUP_MODE_HORIZONTAL') all have the same vertical
     requisition (`GTK_SIZE_GROUP_MODE_VERTICAL'), or should all have
     the same requisition in both directions
     (`GTK_SIZE_GROUP_MODE_BOTH').

    SIZE-GROUP
          a `<gtk-size-group>'

    MODE
          the mode to set for the size group.



 -- Function: gtk-size-group-get-mode (self `<gtk-size-group>') => 
          (ret `<gtk-size-group-mode>')
 -- Method: get-mode
     Gets the current mode of the size group. See
     `gtk-size-group-set-mode'.

    SIZE-GROUP
          a `<gtk-size-group>'

    RET
          the current mode of the size group.



 -- Function: gtk-size-group-set-ignore-hidden
          (self `<gtk-size-group>') (ignore_hidden `bool')
 -- Method: set-ignore-hidden
     Sets whether unmapped widgets should be ignored when calculating
     the size.

    SIZE-GROUP
          a `<gtk-size-group>'

    IGNORE-HIDDEN
          whether unmapped widgets should be ignored when calculating
          the size


     Since 2.8


 -- Function: gtk-size-group-get-ignore-hidden
          (self `<gtk-size-group>') =>  (ret `bool')
 -- Method: get-ignore-hidden
     Returns if invisible widgets are ignored when calculating the size.

    SIZE-GROUP
          a `<gtk-size-group>'

    RET
          ``#t'' if invisible widgets are ignored.


     Since 2.8


 -- Function: gtk-size-group-add-widget (self `<gtk-size-group>')
          (widget `<gtk-widget>')
 -- Method: add-widget
     Adds a widget to a `<gtk-size-group>'. In the future, the
     requisition of the widget will be determined as the maximum of its
     requisition and the requisition of the other widgets in the size
     group. Whether this applies horizontally, vertically, or in both
     directions depends on the mode of the size group. See
     `gtk-size-group-set-mode'.

    SIZE-GROUP
          a `<gtk-size-group>'

    WIDGET
          the `<gtk-widget>' to add



 -- Function: gtk-size-group-remove-widget (self `<gtk-size-group>')
          (widget `<gtk-widget>')
 -- Method: remove-widget
     Removes a widget from a `<gtk-size-group>'.

    SIZE-GROUP
          a `<gtk-size-grup>'

    WIDGET
          the `<gtk-widget>' to remove




File: guile-gnome-gtk.info,  Node: GtkTooltips,  Next: GtkViewport,  Prev: GtkSizeGroup,  Up: Top

127 GtkTooltips
***************

Add tips to your widgets

127.1 Overview
==============

Tooltips are the messages that appear next to a widget when the mouse
pointer is held over it for a short amount of time. They are especially
helpful for adding more verbose descriptions of things such as buttons
in a toolbar.

   An individual tooltip belongs to a group of tooltips. A group is
created with a call to `gtk-tooltips-new'. Every tooltip in the group
can then be turned off with a call to `gtk-tooltips-disable' and
enabled with `gtk-tooltips-enable'.

   The length of time the user must keep the mouse over a widget before
the tip is shown, can be altered with `gtk-tooltips-set-delay'. This is
set on a 'per group of tooltips' basis.

   To assign a tip to a particular `<gtk-widget>',
`gtk-tooltips-set-tip' is used.

   Tooltips can only be set on widgets which have their own X window
and receive enter and leave events. To check if a widget has its own
window use `gtk-widget-no-window'. To add a tooltip to a widget that
doesn't have its own window, place the widget inside a
`<gtk-event-box>' and add a tooltip to that instead.

   The default appearance of all tooltips in a program is determined by
the current GTK+ theme that the user has selected.

   Information about the tooltip (if any) associated with an arbitrary
widget can be retrieved using `gtk-tooltips-data-get'.


        GtkWidget *load_button, *save_button, *hbox;
        GtkTooltips *button_bar_tips;

        button_bar_tips = gtk_tooltips_new ();

        /* Create the buttons and pack them into a GtkHBox */
        hbox = gtk_hbox_new (TRUE, 2);

        load_button = gtk_button_new_with_label ("Load a file");
        gtk_box_pack_start (GTK_BOX (hbox), load_button, TRUE, TRUE, 2);
        gtk_widget_show (load_button);

        save_button = gtk_button_new_with_label ("Save a file");
        gtk_box_pack_start (GTK_BOX (hbox), save_button, TRUE, TRUE, 2);
        gtk_widget_show (save_button);
        gtk_widget_show (hbox);

        /* Add the tips */
        gtk_tooltips_set_tip (GTK_TOOLTIPS (button_bar_tips), load_button,
     				 "Load a new document into this window",
     				 "Requests the filename of a document.
     				  This will then be loaded into the current
     				  window, replacing the contents of whatever
     				  is already loaded.");
        gtk_tooltips_set_tip (GTK_TOOLTIPS (button_bar_tips), save_button,
     				 "Saves the current document to a file",
     				 "If you have saved the document previously,
     				  then the new version will be saved over the
     				  old one. Otherwise, you will be prompted for
     				  a filename.");

127.2 Usage
===========

 -- Class: <gtk-tooltips>
     Derives from `<gtk-object>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-tooltips-new =>  (ret `<gtk-tooltips>')
     Creates an empty group of tooltips. This function initialises a
     `<gtk-tooltips>' structure. Without at least one such structure,
     you can not add tips to your application.

    RET
          a new `<gtk-tooltips>' group for you to use.



 -- Function: gtk-tooltips-enable (self `<gtk-tooltips>')
 -- Method: enable
     Allows the user to see your tooltips as they navigate your
     application.

    TOOLTIPS
          a `<gtk-tooltips>'.



 -- Function: gtk-tooltips-disable (self `<gtk-tooltips>')
 -- Method: disable
     Causes all tooltips in TOOLTIPS to become inactive. Any widgets
     that have tips associated with that group will no longer display
     their tips until they are enabled again with `gtk-tooltips-enable'.

    TOOLTIPS
          a `<gtk-tooltips>'.



 -- Function: gtk-tooltips-set-tip (self `<gtk-tooltips>')
          (widget `<gtk-widget>') (tip_text `mchars')
          (tip_private `mchars')
 -- Method: set-tip
     Adds a tooltip containing the message TIP-TEXT to the specified
     `<gtk-widget>'.

    TOOLTIPS
          a `<gtk-tooltips>'.

    WIDGET
          the `<gtk-widget>' you wish to associate the tip with.

    TIP-TEXT
          a string containing the tip itself.

    TIP-PRIVATE
          a string of any further information that may be useful if the
          user gets stuck.



 -- Function: gtk-tooltips-force-window (self `<gtk-tooltips>')
 -- Method: force-window
     Ensures that the window used for displaying the given TOOLTIPS is
     created.

     Applications should never have to call this function, since GTK+
     takes care of this.

    TOOLTIPS
          a `<gtk-tool-tips>'




File: guile-gnome-gtk.info,  Node: GtkViewport,  Next: GtkAccessible,  Prev: GtkTooltips,  Up: Top

128 GtkViewport
***************

An adapter which makes widgets scrollable

128.1 Overview
==============

128.2 Usage
===========

 -- Class: <gtk-viewport>
     Derives from `<gtk-bin>'.

     This class defines the following properties:

    `hadjustment'
          The GtkAdjustment that determines the values of the
          horizontal position for this viewport

    `vadjustment'
          The GtkAdjustment that determines the values of the vertical
          position for this viewport

    `shadow-type'
          Determines how the shadowed box around the viewport is drawn



 -- Signal on <gtk-viewport>: set-scroll-adjustments
          (arg0 `<gtk-adjustment>') (arg1 `<gtk-adjustment>')

 -- Function: gtk-viewport-new (hadjustment `<gtk-adjustment>')
          (vadjustment `<gtk-adjustment>') =>  (ret `<gtk-widget>')
     Creates a new `<gtk-viewport>' with the given adjustments.

    HADJUSTMENT
          horizontal adjustment.

    VADJUSTMENT
          vertical adjustment.

    RET
          a new `<gtk-viewport>'.



 -- Function: gtk-viewport-get-hadjustment (self `<gtk-viewport>') => 
          (ret `<gtk-adjustment>')
 -- Method: get-hadjustment
     Returns the horizontal adjustment of the viewport.

    VIEWPORT
          a `<gtk-viewport>'.

    RET
          the horizontal adjustment of VIEWPORT.



 -- Function: gtk-viewport-get-vadjustment (self `<gtk-viewport>') => 
          (ret `<gtk-adjustment>')
 -- Method: get-vadjustment
     Returns the vertical adjustment of the viewport.

    VIEWPORT
          a `<gtk-viewport>'.

    RET
          the vertical adjustment of VIEWPORT.



 -- Function: gtk-viewport-set-hadjustment (self `<gtk-viewport>')
          (adjustment `<gtk-adjustment>')
 -- Method: set-hadjustment
     Sets the horizontal adjustment of the viewport.

    VIEWPORT
          a `<gtk-viewport>'.

    ADJUSTMENT
          a `<gtk-adjustment>'.



 -- Function: gtk-viewport-set-vadjustment (self `<gtk-viewport>')
          (adjustment `<gtk-adjustment>')
 -- Method: set-vadjustment
     Sets the vertical adjustment of the viewport.

    VIEWPORT
          a `<gtk-viewport>'.

    ADJUSTMENT
          a `<gtk-adjustment>'.



 -- Function: gtk-viewport-set-shadow-type (self `<gtk-viewport>')
          (type `<gtk-shadow-type>')
 -- Method: set-shadow-type
     Sets the shadow type of the viewport.

    VIEWPORT
          a `<gtk-viewport>'.

    TYPE
          the new shadow type.



 -- Function: gtk-viewport-get-shadow-type (self `<gtk-viewport>') => 
          (ret `<gtk-shadow-type>')
 -- Method: get-shadow-type
     Gets the shadow type of the `<gtk-viewport>'. See
     `gtk-viewport-set-shadow-type'.

    VIEWPORT
          a `<gtk-viewport>'

    RET
          the shadow type




File: guile-gnome-gtk.info,  Node: GtkAccessible,  Next: GtkBin,  Prev: GtkViewport,  Up: Top

129 GtkAccessible
*****************

Accessibility support for widgets

129.1 Overview
==============

129.2 Usage
===========

 -- Class: <gtk-accessible>
     Derives from `<atk-object>'.

     This class defines no properties, other than those defined by its
     superclasses.



File: guile-gnome-gtk.info,  Node: GtkBin,  Next: GtkBox,  Prev: GtkAccessible,  Up: Top

130 GtkBin
**********

A container with just one child

130.1 Overview
==============

The `<gtk-bin>' widget is a container with just one child. It is not
very useful itself, but it is useful for deriving subclasses, since it
provides common code needed for handling a single child widget.

   Many GTK+ widgets are subclasses of `<gtk-bin>', including
`<gtk-window>', `<gtk-button>', `<gtk-frame>', `<gtk-handle-box>', and
`<gtk-scrolled-window>'.

130.2 Usage
===========

 -- Class: <gtk-bin>
     Derives from `<gtk-container>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-bin-get-child (self `<gtk-bin>') => 
          (ret `<gtk-widget>')
 -- Method: get-child
     Gets the child of the `<gtk-bin>', or ``#f'' if the bin contains
     no child widget. The returned widget does not have a reference
     added, so you do not need to unref it.

    BIN
          a `<gtk-bin>'

    RET
          pointer to child of the `<gtk-bin>'




File: guile-gnome-gtk.info,  Node: GtkBox,  Next: GtkButtonBox,  Prev: GtkBin,  Up: Top

131 GtkBox
**********

Base class for box containers

131.1 Overview
==============

GtkBox is an abstract widget which encapsulates functionallity for a
particular kind of container, one that organizes a variable number of
widgets into a rectangular area. GtkBox currently has two derived
classes, `<gtk-hbox>' and `<gtk-vbox>'.

   The rectangular area of a GtkBox is organized into either a single
row or a single column of child widgets depending upon whether the box
is of type `<gtk-hbox>' or `<gtk-vbox>', respectively. Thus, all
children of a GtkBox are allocated one dimension in common, which is
the height of a row, or the width of a column.

   GtkBox uses a notion of _packing_. Packing refers to adding widgets
with reference to a particular position in a `<gtk-container>'. For a
GtkBox, there are two reference positions: the _start_ and the _end_ of
the box. For a `<gtk-vbox>', the start is defined as the top of the box
and the end is defined as the bottom. For a `<gtk-hbox>' the start is
defined as the left side and the end is defined as the right side.

   Use repeated calls to `gtk-box-pack-start' to pack widgets into a
GtkBox from start to end. Use `gtk-box-pack-end' to add widgets from
end to start.  You may intersperse these calls and add widgets from
both ends of the same GtkBox.

   Use `gtk-box-pack-start-defaults' or `gtk-box-pack-end-defaults' to
pack widgets into a GtkBox if you do not need to specify the , , or
attributes of the child to be added.

   Because GtkBox is a `<gtk-container>', you may also use
`gtk-container-add' to insert widgets into the box, and they will be
packed as if with `gtk-box-pack-start-defaults'. Use
`gtk-container-remove' to remove widgets from the GtkBox.

   Use `gtk-box-set-homogeneous' to specify whether or not all children
of the GtkBox are forced to get the same amount of space.

   Use `gtk-box-set-spacing' to determine how much space will be
minimally placed between all children in the GtkBox.

   Use `gtk-box-reorder-child' to move a GtkBox child to a different
place in the box.

   Use `gtk-box-set-child-packing' to reset the , , and attributes of
any GtkBox child. Use `gtk-box-query-child-packing' to query these
fields.

131.2 Usage
===========

 -- Class: <gtk-box>
     Derives from `<gtk-container>'.

     This class defines the following properties:

    `spacing'
          The amount of space between children

    `homogeneous'
          Whether the children should all be the same size



 -- Function: gtk-box-pack-start (self `<gtk-box>')
          (child `<gtk-widget>') (expand `bool') (fill `bool')
          (padding `unsigned-int')
 -- Method: pack-start
     Adds CHILD to BOX, packed with reference to the start of BOX.  The
     CHILD is packed after any other child packed with reference to the
     start of BOX.

    BOX
          a `<gtk-box>'.

    CHILD
          the `<gtk-widget>' to be added to BOX.

    EXPAND
          ``#t'' if the new child is to be given extra space allocated
          to BOX. The extra space will be divided evenly between all
          children of BOX that use this option.

    FILL
          ``#t'' if space given to CHILD by the EXPAND option is
          actually allocated to CHILD, rather than just padding it.
          This parameter has no effect if EXPAND is set to ``#f''. A
          child is always allocated the full height of a `<gtk-hbox>'
          and the full width of a `<gtk-vbox>'. This option affects the
          other dimension.

    PADDING
          extra space in pixels to put between this child and its
          neighbors, over and above the global amount specified by
          `<gtk-box>'. If CHILD is a widget at one of the reference
          ends of BOX, then PADDING pixels are also put between CHILD
          and the reference edge of BOX.



 -- Function: gtk-box-pack-end (self `<gtk-box>')
          (child `<gtk-widget>') (expand `bool') (fill `bool')
          (padding `unsigned-int')
 -- Method: pack-end
     Adds CHILD to BOX, packed with reference to the end of BOX.  The
     CHILD is packed after (away from end of) any other child packed
     with reference to the end of BOX.

    BOX
          a `<gtk-box>'.

    CHILD
          the `<gtk-widget>' to be added to BOX.

    EXPAND
          ``#t'' if the new child is to be given extra space allocated
          to BOX. The extra space will be divided evenly between all
          children of BOX that use this option.

    FILL
          ``#t'' if space given to CHILD by the EXPAND option is
          actually allocated to CHILD, rather than just padding it.
          This parameter has no effect if EXPAND is set to ``#f''. A
          child is always allocated the full height of a `<gtk-hbox>'
          and the full width of a `<gtk-vbox>'. This option affects the
          other dimension.

    PADDING
          extra space in pixels to put between this child and its
          neighbors, over and above the global amount specified by
          `<gtk-box>'. If CHILD is a widget at one of the reference
          ends of BOX, then PADDING pixels are also put between CHILD
          and the reference edge of BOX.



 -- Function: gtk-box-pack-start-defaults (self `<gtk-box>')
          (widget `<gtk-widget>')
 -- Method: pack-start-defaults
     Adds WIDGET to BOX, packed with reference to the start of BOX.
     The child is packed after any other child packed with reference to
     the start of BOX.

     Parameters for how to pack the child WIDGET, `<gtk-box-child>',
     are given their default values, ``#t'', ``#t'', and 0,
     respectively.

    BOX
          a `<gtk-box>'.

    WIDGET
          the `<gtk-widget>' to be added to BOX.



 -- Function: gtk-box-pack-end-defaults (self `<gtk-box>')
          (widget `<gtk-widget>')
 -- Method: pack-end-defaults
     Adds WIDGET to BOX, packed with reference to the end of BOX.  The
     child is packed after (away from end of) any other child packed
     with reference to the end of BOX.

     Parameters for how to pack the child WIDGET, `<gtk-box-child>',
     are given their default values, ``#t'', ``#t'', and 0,
     respectively.

    BOX
          a `<gtk-box>'.

    WIDGET
          the `<gtk-widget>' to be added to BOX.



 -- Function: gtk-box-get-homogeneous (self `<gtk-box>') => 
          (ret `bool')
 -- Method: get-homogeneous
     Returns whether the box is homogeneous (all children are the same
     size). See `gtk-box-set-homogeneous'.

    BOX
          a `<gtk-box>'

    RET
          ``#t'' if the box is homogeneous.



 -- Function: gtk-box-set-homogeneous (self `<gtk-box>')
          (homogeneous `bool')
 -- Method: set-homogeneous
     Sets the whether or not all children of BOX are given equal space
     in the box.

    BOX
          a `<gtk-box>'.

    HOMOGENEOUS
          a boolean value, ``#t'' to create equal allotments, ``#f''
          for variable allotments.



 -- Function: gtk-box-get-spacing (self `<gtk-box>') =>  (ret `int')
 -- Method: get-spacing
     Gets the value set by `gtk-box-set-spacing'.

    BOX
          a `<gtk-box>'

    RET
          spacing between children



 -- Function: gtk-box-set-spacing (self `<gtk-box>') (spacing `int')
 -- Method: set-spacing
     Sets the number of pixels to place between children of BOX.

    BOX
          a `<gtk-box>'.

    SPACING
          the number of pixels to put between children.



 -- Function: gtk-box-reorder-child (self `<gtk-box>')
          (child `<gtk-widget>') (position `int')
 -- Method: reorder-child
     Moves CHILD to a new POSITION in the list of BOX children. The
     list is the both widgets packed `<gtk-pack-start>' as well as
     widgets packed `<gtk-pack-end>', in the order that these widgets
     were added to BOX.

     A widget's position in the BOX children list determines where the
     widget is packed into BOX. A child widget at some position in the
     list will be packed just after all other widgets of the same
     packing type that appear earlier in the list.

    BOX
          a `<gtk-box>'.

    CHILD
          the `<gtk-widget>' to move.

    POSITION
          the new position for CHILD in the `<gtk-box>', starting from
          0. If negative, indicates the end of the list.



 -- Function: gtk-box-set-child-packing (self `<gtk-box>')
          (child `<gtk-widget>') (expand `bool') (fill `bool')
          (padding `unsigned-int') (pack_type `<gtk-pack-type>')
 -- Method: set-child-packing
     Sets the way CHILD is packed into BOX.

    BOX
          a `<gtk-box>'.

    CHILD
          the `<gtk-widget>' of the child to set.

    EXPAND
          the new value of the

    FILL
          the new value of the

    PADDING
          the new value of the

    PACK-TYPE
          the new value of the



File: guile-gnome-gtk.info,  Node: GtkButtonBox,  Next: GtkContainer,  Prev: GtkBox,  Up: Top

132 GtkButtonBox
****************

Base class for and

132.1 Overview
==============

The primary purpose of this class is to keep track of the various
properties of `<gtk-hbutton-box>' and `<gtk-vbutton-box>' widgets.

   `gtk-button-box-get-child-size' retrieves the minimum width and
height for widgets in a given button box.
`gtk-button-box-set-child-size' allows those properties to be changed.

   The internal padding of buttons can be retrieved and changed per
button box using `gtk-button-box-get-child-ipadding' and
`gtk-button-box-set-child-ipadding' respectively.

   `gtk-button-box-get-spacing' and `gtk-button-box-set-spacing'
retrieve and change default number of pixels between buttons,
respectively.

   `gtk-button-box-get-layout' and `gtk-button-box-set-layout' retrieve
and alter the method used to spread the buttons in a button box across
the container, respectively.

   The main purpose of GtkButtonBox is to make sure the children have
all the same size. Therefore it ignores the homogeneous property which
it inherited from GtkBox, and always behaves as if homogeneous was
``#t''.

132.2 Usage
===========

 -- Class: <gtk-button-box>
     Derives from `<gtk-box>'.

     This class defines the following properties:

    `layout-style'
          How to layout the buttons in the box. Possible values are
          default, spread, edge, start and end



 -- Function: gtk-button-box-get-layout (self `<gtk-button-box>') => 
          (ret `<gtk-button-box-style>')
 -- Method: get-layout
     Retrieves the method being used to arrange the buttons in a button
     box.

    WIDGET
          a `<gtk-button-box>'.

    RET
          the method used to layout buttons in WIDGET.



 -- Function: gtk-button-box-get-child-secondary
          (self `<gtk-button-box>') (child `<gtk-widget>') => 
          (ret `bool')
 -- Method: get-child-secondary
     Returns whether CHILD should appear in a secondary group of
     children.

    WIDGET
          a `<gtk-button-box>'

    CHILD
          a child of WIDGET

    RET
          whether CHILD should appear in a secondary group of children.


     Since 2.4


 -- Function: gtk-button-box-set-layout (self `<gtk-button-box>')
          (layout_style `<gtk-button-box-style>')
 -- Method: set-layout
     Changes the way buttons are arranged in their container.

    WIDGET
          a `<gtk-button-box>'.

    LAYOUT-STYLE
          the new layout style.



 -- Function: gtk-button-box-set-child-secondary
          (self `<gtk-button-box>') (child `<gtk-widget>')
          (is_secondary `bool')
 -- Method: set-child-secondary
     Sets whether CHILD should appear in a secondary group of children.
     A typical use of a secondary child is the help button in a dialog.

     This group appears after the other children if the style is
     `GTK_BUTTONBOX_START', `GTK_BUTTONBOX_SPREAD' or
     `GTK_BUTTONBOX_EDGE', and before the other children if the style is
     `GTK_BUTTONBOX_END'. For horizontal button boxes, the definition of
     before/after depends on direction of the widget (see
     `gtk-widget-set-direction'). If the style is `GTK_BUTTONBOX_START'
     or `GTK_BUTTONBOX_END', then the secondary children are aligned at
     the other end of the button box from the main children. For the
     other styles, they appear immediately next to the main children.

    WIDGET
          a `<gtk-button-box>'

    CHILD
          a child of WIDGET

    IS-SECONDARY
          if ``#t'', the CHILD appears in a secondary group of the
          button box.




File: guile-gnome-gtk.info,  Node: GtkContainer,  Next: GtkItem,  Prev: GtkButtonBox,  Up: Top

133 GtkContainer
****************

Base class for widgets which contain other widgets

133.1 Overview
==============

A GTK+ user interface is constructed by nesting widgets inside widgets.
Container widgets are the inner nodes in the resulting tree of widgets:
they contain other widgets. So, for example, you might have a
`<gtk-window>' containing a `<gtk-frame>' containing a GtkLabel. If you
wanted an image instead of a textual label inside the frame, you might
replace the `<gtk-label>' widget with a `<gtk-image>' widget.

   There are two major kinds of container widgets in GTK+. Both are
subclasses of the abstract `<gtk-container>' base class.

   The first type of container widget has a single child widget and
derives from `<gtk-bin>'. These containers are "decorators", which add
some kind of functionality to the child. For example, a `<gtk-button>'
makes its child into a clickable button; a `<gtk-frame>' draws a frame
around its child and a `<gtk-window>' places its child widget inside a
top-level window.

   The second type of container can have more than one child; its
purpose is to manage "layout". This means that these containers assign
sizes and positions to their children. For example, a `<gtk-hbox>'
arranges its children in a horizontal row, and a `<gtk-table>' arranges
the widgets it contains in a two-dimensional grid.

   To fulfill its task, a layout container must negotiate the size
requirements with its parent and its children. This negotiation is
carried out in two phases, "size requisition" and "size allocation".

133.2 Size Requisition
======================

The size requisition of a widget is it's desired width and height. This
is represented by a `<gtk-requisition>'.

   How a widget determines its desired size depends on the widget. A
`<gtk-label>', for example, requests enough space to display all its
text.  Container widgets generally base their size request on the
requisitions of their children.

   The size requisition phase of the widget layout process operates
top-down. It starts at a top-level widget, typically a `<gtk-window>'.
The top-level widget asks its child for its size requisition by calling
`gtk-widget-size-request'. To determine its requisition, the child asks
its own children for their requisitions and so on. Finally, the
top-level widget will get a requisition back from its child.

133.3 Size Allocation
=====================

When the top-level widget has determined how much space its child would
like to have, the second phase of the size negotiation, size
allocation, begins.  Depending on its configuration (see
`gtk-window-set-resizable'), the top-level widget may be able to expand
in order to satisfy the size request or it may have to ignore the size
request and keep its fixed size. It then tells its child widget how
much space it gets by calling `gtk-widget-size-allocate'. The child
widget divides the space among its children and tells each child how
much space it got, and so on. Under normal circumstances, a
`<gtk-window>' will always give its child the amount of space the child
requested.

   A child's size allocation is represented by a `<gtk-allocation>'.
This struct contains not only a width and height, but also a position
(i.e. X and Y coordinates), so that containers can tell their children
not only how much space they have gotten, but also where they are
positioned inside the space available to the container.

   Widgets are required to honor the size allocation they receive; a
size request is only a request, and widgets must be able to cope with
any size.

133.4 Child properties
======================

introduces "child properties" - these are object properties that are not
specific to either the container or the contained widget, but rather to
their relation. Typical examples of child properties are the position
or pack-type of a widget which is contained in a `<gtk-box>'.

   Use `gtk-container-class-install-child-property' to install child
properties for a container class and
`gtk-container-class-find-child-property' or
`gtk-container-class-list-child-properties' to get information about
existing child properties.

   To set the value of a child property, use
`gtk-container-child-set-property', `gtk-container-child-set' or
`gtk-container-child-set-valist'. To obtain the value of a child
property, use `gtk-container-child-get-property',
`gtk-container-child-get' or `gtk-container-child-get-valist'. To emit
notification about child property changes, use
`gtk-widget-child-notify'.

133.5 Usage
===========

 -- Class: <gtk-container>
     Derives from `<gtk-widget>'.

     This class defines the following properties:

    `border-width'
          The width of the empty border outside the containers children

    `resize-mode'
          Specify how resize events are handled

    `child'
          Can be used to add a new child to the container



 -- Signal on <gtk-container>: add (arg0 `<gtk-widget>')

 -- Signal on <gtk-container>: remove (arg0 `<gtk-widget>')

 -- Signal on <gtk-container>: check-resize

 -- Signal on <gtk-container>: set-focus-child (arg0 `<gtk-widget>')

 -- Function: gtk-container-add (self `<gtk-container>')
          (widget `<gtk-widget>')
 -- Method: add
     Adds WIDGET to CONTAINER. Typically used for simple containers such
     as `<gtk-window>', `<gtk-frame>', or `<gtk-button>'; for more
     complicated layout containers such as `<gtk-box>' or `<gtk-table>',
     this function will pick default packing parameters that may not be
     correct. So consider functions such as `gtk-box-pack-start' and
     `gtk-table-attach' as an alternative to `gtk-container-add' in
     those cases. A widget may be added to only one container at a
     time; you can't place the same widget inside two different
     containers.

    CONTAINER
          a `<gtk-container>'

    WIDGET
          a widget to be placed inside CONTAINER



 -- Function: gtk-container-remove (self `<gtk-container>')
          (widget `<gtk-widget>')
 -- Method: remove
     Removes WIDGET from CONTAINER. WIDGET must be inside CONTAINER.
     Note that CONTAINER will own a reference to WIDGET, and that this
     may be the last reference held; so removing a widget from its
     container can destroy that widget. If you want to use WIDGET
     again, you need to add a reference to it while it's not inside a
     container, using `g-object-ref'. If you don't want to use WIDGET
     again it's usually more efficient to simply destroy it directly
     using `gtk-widget-destroy' since this will remove it from the
     container and help break any circular reference count cycles.

    CONTAINER
          a `<gtk-container>'

    WIDGET
          a current child of CONTAINER



 -- Function: gtk-container-get-resize-mode (self `<gtk-container>')
          =>  (ret `<gtk-resize-mode>')
 -- Method: get-resize-mode
     Returns the resize mode for the container. See
     `gtk-container-set-resize-mode'.

    CONTAINER
          a `<gtk-container>'

    RET
          the current resize mode



 -- Function: gtk-container-set-resize-mode (self `<gtk-container>')
          (resize_mode `<gtk-resize-mode>')
 -- Method: set-resize-mode
     Sets the resize mode for the container.

     The resize mode of a container determines whether a resize request
     will be passed to the container's parent, queued for later
     execution or executed immediately.

    CONTAINER
          a `<gtk-container>'.

    RESIZE-MODE
          the new resize mode.



 -- Function: gtk-container-check-resize (self `<gtk-container>')
 -- Method: check-resize
    CONTAINER


 -- Function: gtk-container-get-children (self `<gtk-container>') => 
          (ret `glist-of')
 -- Method: get-children
     Returns the container's non-internal children. See
     `gtk-container-forall' for details on what constitutes an
     "internal" child.

    CONTAINER
          a `<gtk-container>'.

    RET
          a newly-allocated list of the container's non-internal
          children.



 -- Function: gtk-container-set-focus-child (self `<gtk-container>')
          (child `<gtk-widget>')
 -- Method: set-focus-child
    CONTAINER

    CHILD


 -- Function: gtk-container-get-focus-vadjustment
          (self `<gtk-container>') =>  (ret `<gtk-adjustment>')
 -- Method: get-focus-vadjustment
     Retrieves the vertical focus adjustment for the container. See
     `gtk-container-set-focus-vadjustment'.

    CONTAINER
          a `<gtk-container>'

    RET
          the vertical focus adjustment, or ``#f'' if none has been set.



 -- Function: gtk-container-set-focus-vadjustment
          (self `<gtk-container>') (adjustment `<gtk-adjustment>')
 -- Method: set-focus-vadjustment
     Hooks up an adjustment to focus handling in a container, so when a
     child of the container is focused, the adjustment is scrolled to
     show that widget. This function sets the vertical alignment. See
     `gtk-scrolled-window-get-vadjustment' for a typical way of
     obtaining the adjustment and `gtk-container-set-focus-hadjustment'
     for setting the horizontal adjustment.

     The adjustments have to be in pixel units and in the same
     coordinate system as the allocation for immediate children of the
     container.

    CONTAINER
          a `<gtk-container>'

    ADJUSTMENT
          an adjustment which should be adjusted when the focus is
          moved among the descendents of CONTAINER



 -- Function: gtk-container-get-focus-hadjustment
          (self `<gtk-container>') =>  (ret `<gtk-adjustment>')
 -- Method: get-focus-hadjustment
     Retrieves the horizontal focus adjustment for the container. See
     `gtk-container-set-focus-hadjustment'.

    CONTAINER
          a `<gtk-container>'

    RET
          the horizontal focus adjustment, or ``#f'' if none has been
          set.



 -- Function: gtk-container-set-focus-hadjustment
          (self `<gtk-container>') (adjustment `<gtk-adjustment>')
 -- Method: set-focus-hadjustment
     Hooks up an adjustment to focus handling in a container, so when a
     child of the container is focused, the adjustment is scrolled to
     show that widget. This function sets the horizontal alignment. See
     `gtk-scrolled-window-get-hadjustment' for a typical way of
     obtaining the adjustment and `gtk-container-set-focus-vadjustment'
     for setting the vertical adjustment.

     The adjustments have to be in pixel units and in the same
     coordinate system as the allocation for immediate children of the
     container.

    CONTAINER
          a `<gtk-container>'

    ADJUSTMENT
          an adjustment which should be adjusted when the focus is
          moved among the descendents of CONTAINER



 -- Function: gtk-container-resize-children (self `<gtk-container>')
 -- Method: resize-children
    CONTAINER


 -- Function: gtk-container-child-type (self `<gtk-container>') => 
          (ret `<gtype>')
 -- Method: child-type
     Returns the type of the children supported by the container.

     Note that this may return `G_TYPE_NONE' to indicate that no more
     children can be added, e.g. for a `<gtk-paned>' which already has
     two children.

    CONTAINER
          a `<gtk-container>'.

    RET
          a `<g-type>'.



 -- Function: gtk-container-child-get-property (self `<gtk-container>')
          (child `<gtk-widget>') (property_name `mchars')
          (value `<gvalue>')
 -- Method: child-get-property
     Gets the value of a child property for CHILD and CONTAINER.

    CONTAINER
          a `<gtk-container>'

    CHILD
          a widget which is a child of CONTAINER

    PROPERTY-NAME
          the name of the property to get

    VALUE
          a location to return the value



 -- Function: gtk-container-child-set-property (self `<gtk-container>')
          (child `<gtk-widget>') (property_name `mchars')
          (value `<gvalue>')
 -- Method: child-set-property
     Sets a child property for CHILD and CONTAINER.

    CONTAINER
          a `<gtk-container>'

    CHILD
          a widget which is a child of CONTAINER

    PROPERTY-NAME
          the name of the property to set

    VALUE
          the value to set the property to



 -- Function: gtk-container-get-border-width (self `<gtk-container>')
          =>  (ret `unsigned-int')
 -- Method: get-border-width
     Retrieves the border width of the container. See
     `gtk-container-set-border-width'.

    CONTAINER
          a `<gtk-container>'

    RET
          the current border width



 -- Function: gtk-container-set-border-width (self `<gtk-container>')
          (border_width `unsigned-int')
 -- Method: set-border-width
     Sets the border width of the container.

     The border width of a container is the amount of space to leave
     around the outside of the container. The only exception to this is
     `<gtk-window>'; because toplevel windows can't leave space
     outside, they leave the space inside.  The border is added on all
     sides of the container. To add space to only one side, one
     approach is to create a `<gtk-alignment>' widget, call
     `gtk-widget-set-usize' to give it a size, and place it on the side
     of the container as a spacer.

    CONTAINER
          a `<gtk-container>'

    BORDER-WIDTH
          amount of blank space to leave _outside_ the container. Valid
          values are in the range 0-65535 pixels.



 -- Function: gtk-container-propagate-expose (self `<gtk-container>')
          (child `<gtk-widget>') (event `<gdk-event-expose>')
 -- Method: propagate-expose
     When a container receives an expose event, it must send synthetic
     expose events to all children that don't have their own
     `<gdk-windows>'. This function provides a convenient way of doing
     this. A container, when it receives an expose event, calls
     `gtk-container-propagate-expose' once for each child, passing in
     the event the container received.

     `gtk-container-propagate-expose' takes care of deciding whether an
     expose event needs to be sent to the child, intersecting the
     event's area with the child area, and sending the event.

     In most cases, a container can simply either simply inherit the
     ::expose implementation from `<gtk-container>', or, do some
     drawing and then chain to the ::expose implementation from
     `<gtk-container>'.

    CONTAINER
          a `<gtk-container>'

    CHILD
          a child of CONTAINER

    EVENT
          a expose event sent to container



 -- Function: gtk-container-set-focus-chain (self `<gtk-container>')
          (focusable_widgets `glist-of')
 -- Method: set-focus-chain
     Sets a focus chain, overriding the one computed automatically by
     GTK+.

     In principle each widget in the chain should be a descendant of
     the container, but this is not enforced by this method, since it's
     allowed to set the focus chain before you pack the widgets, or
     have a widget in the chain that isn't always packed. The necessary
     checks are done when the focus chain is actually traversed.

    CONTAINER
          a `<gtk-container>'.

    FOCUSABLE-WIDGETS
          the new focus chain.



 -- Function: gtk-container-unset-focus-chain (self `<gtk-container>')
 -- Method: unset-focus-chain
     Removes a focus chain explicitly set with
     `gtk-container-set-focus-chain'.

    CONTAINER
          a `<gtk-container>'.




File: guile-gnome-gtk.info,  Node: GtkItem,  Next: GtkMisc,  Prev: GtkContainer,  Up: Top

134 GtkItem
***********

Abstract base class for GtkMenuItem, GtkListItem and GtkTreeItem

134.1 Overview
==============

The `<gtk-item>' widget is an abstract base class for
`<gtk-menu-item>', `<gtk-list-item>' and `<gtk-tree-item>'.

134.2 Usage
===========

 -- Class: <gtk-item>
     Derives from `<gtk-bin>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Signal on <gtk-item>: select
     Emitted when the item is selected.


 -- Signal on <gtk-item>: deselect
     Emitted when the item is deselected.


 -- Signal on <gtk-item>: toggle
     Emitted when the item is toggled.


 -- Function: gtk-item-select (self `<gtk-item>')
 -- Method: select
     Emits the "select" signal on the given item.

    ITEM
          a `<gtk-item>'.



 -- Function: gtk-item-deselect (self `<gtk-item>')
 -- Method: deselect
     Emits the "deselect" signal on the given item.

    ITEM
          a `<gtk-item>'.



 -- Function: gtk-item-toggle (self `<gtk-item>')
 -- Method: toggle
     Emits the "toggle" signal on the given item.

    ITEM
          a `<gtk-item>'.




File: guile-gnome-gtk.info,  Node: GtkMisc,  Next: GtkObject,  Prev: GtkItem,  Up: Top

135 GtkMisc
***********

Base class for widgets with alignments and padding

135.1 Overview
==============

The `<gtk-misc>' widget is an abstract widget which is not useful
itself, but is used to derive subclasses which have alignment and
padding attributes.

   The horizontal and vertical padding attributes allows extra space to
be added around the widget.

   The horizontal and vertical alignment attributes enable the widget
to be positioned within its allocated area. Note that if the widget is
added to a container in such a way that it expands automatically to
fill its allocated area, the alignment settings will not alter the
widgets position.

135.2 Usage
===========

 -- Class: <gtk-misc>
     Derives from `<gtk-widget>'.

     This class defines the following properties:

    `xalign'
          The horizontal alignment, from 0 (left) to 1 (right).
          Reversed for RTL layouts.

    `yalign'
          The vertical alignment, from 0 (top) to 1 (bottom)

    `xpad'
          The amount of space to add on the left and right of the
          widget, in pixels

    `ypad'
          The amount of space to add on the top and bottom of the
          widget, in pixels



 -- Function: gtk-misc-set-alignment (self `<gtk-misc>')
          (xalign `float') (yalign `float')
 -- Method: set-alignment
     Sets the alignment of the widget.

    MISC
          a `<gtk-misc>'.

    XALIGN
          the horizontal alignment, from 0 (left) to 1 (right).

    YALIGN
          the vertical alignment, from 0 (top) to 1 (bottom).



 -- Function: gtk-misc-set-padding (self `<gtk-misc>') (xpad `int')
          (ypad `int')
 -- Method: set-padding
     Sets the amount of space to add around the widget.

    MISC
          a `<gtk-misc>'.

    XPAD
          the amount of space to add on the left and right of the
          widget, in pixels.

    YPAD
          the amount of space to add on the top and bottom of the
          widget, in pixels.



 -- Function: gtk-misc-get-alignment (self `<gtk-misc>') => 
          (xalign `float') (yalign `float')
 -- Method: get-alignment
     Gets the X and Y alignment of the widget within its allocation. See
     `gtk-misc-set-alignment'.

    MISC
          a `<gtk-misc>'

    XALIGN
          location to store X alignment of MISC, or ``#f''

    YALIGN
          location to store Y alignment of MISC, or ``#f''



 -- Function: gtk-misc-get-padding (self `<gtk-misc>') =>  (xpad `int')
          (ypad `int')
 -- Method: get-padding
     Gets the padding in the X and Y directions of the widget. See
     `gtk-misc-set-padding'.

    MISC
          a `<gtk-misc>'

    XPAD
          location to store padding in the X direction, or ``#f''

    YPAD
          location to store padding in the Y direction, or ``#f''




File: guile-gnome-gtk.info,  Node: GtkObject,  Next: GtkPaned,  Prev: GtkMisc,  Up: Top

136 GtkObject
*************

The base class of the GTK+ type hierarchy

136.1 Overview
==============

136.2 Description
=================

`<gtk-object>' is the base class for all widgets, and for a few
non-widget objects such as `<gtk-adjustment>'. `<gtk-object>' predates
`<gobject>'; non-widgets that derive from `<gtk-object>' rather than
`<gobject>' do so for backward compatibility reasons.

   `<gtk-object>'s are created with a "floating" reference count. This
means that the initial reference is not owned by anyone. Calling
`g-object-unref' on a newly-created `<gtk-object>' is incorrect, the
floating reference has to be removed first. This can be done by anyone
at any time, by calling `g-object-ref-sink' to convert the floating
reference into a regular reference. `g-object-ref-sink' returns a new
reference if an object is already sunk (has no floating reference).

   When you add a widget to its parent container, the parent container
will do this: This means that the container now owns a reference to the
child widget and the child widget has no floating reference.


       g_object_ref_sink (G_OBJECT (child_widget));

   The purpose of the floating reference is to keep the child widget
alive until you add it to a parent container:


        button = gtk_button_new ();
        /* button has one floating reference to keep it alive */
        gtk_container_add (GTK_CONTAINER (container), button);
        /* button has one non-floating reference owned by the container */

   `<gtk-window>' is a special case, because GTK+ itself will ref/sink
it on creation. That is, after calling `gtk-window-new', the
`<gtk-window>' will have one reference which is owned by GTK+, and no
floating references.

   One more factor comes into play: the "destroy" signal, emitted by the
`gtk-object-destroy' method. The "destroy" signal asks all code owning a
reference to an object to release said reference. So, for example, if
you call `gtk-object-destroy' on a `<gtk-window>', GTK+ will release the
reference count that it owns; if you call `gtk-object-destroy' on a
`<gtk-button>', then the button will be removed from its parent
container and the parent container will release its reference to the
button. Because these references are released, calling
`gtk-object-destroy' should result in freeing all memory associated
with an object, unless some buggy code fails to release its references
in response to the "destroy" signal. Freeing memory (referred to as
"finalization" only happens if the reference count reaches zero.

   Some simple rules for handling `<gtk-object:>'

   Never call `g-object-unref' unless you have previously called
`g-object-ref', even if you created the `<gtk-object>'. (Note: this is
_not_ true for `<gobject>'; for `<gobject>', the creator of the object
owns a reference.)

   Call `gtk-object-destroy' to get rid of most objects in most cases.
In particular, widgets are almost always destroyed in this way.

   Because of the floating reference count, you don't need to worry
about reference counting for widgets and toplevel windows, unless you
explicitly call `g-object-ref' yourself.

136.3 Usage
===========

 -- Class: <gtk-object>
     Derives from `<g-initially-unowned>'.

     This class defines the following properties:

    `user-data'
          Anonymous User Data Pointer



 -- Signal on <gtk-object>: destroy
     Signals that all holders of a reference to the `<gtk-object>'
     should release the reference that they hold. May result in
     finalization of the object if all references are released.



File: guile-gnome-gtk.info,  Node: GtkPaned,  Next: GtkRange,  Prev: GtkObject,  Up: Top

137 GtkPaned
************

Base class for widgets with two adjustable panes

137.1 Overview
==============

`<gtk-paned>' is the base class for widgets with two panes, arranged
either horizontally (`<gtk-hpaned>') or vertically (`<gtk-vpaned>').
Child widgets are added to the panes of the widget with
`gtk-paned-pack1' and `gtk-paned-pack2'. The division beween the two
children is set by default from the size requests of the children, but
it can be adjusted by the user.

   A paned widget draws a separator between the two child widgets and a
small handle that the user can drag to adjust the division. It does not
draw any relief around the children or around the separator. (The space
in which the separator is called the gutter.) Often, it is useful to
put each child inside a `<gtk-frame>' with the shadow type set to
`GTK_SHADOW_IN' so that the gutter appears as a ridge.

   Each child has two options that can be set, RESIZE and SHRINK. If
RESIZE is true, then when the `<gtk-paned>' is resized, that child will
expand or shrink along with the paned widget. If SHRINK is true, then
when that child can be made smaller than its requisition by the user.
Setting SHRINK to ``#f'' allows the application to set a minimum size.
If RESIZE is false for both children, then this is treated as if RESIZE
is true for both children.

   The application can set the position of the slider as if it were set
by the user, by calling `gtk-paned-set-position'.


     GtkWidget *hpaned = gtk_hpaned_new ();
     GtkWidget *frame1 = gtk_frame_new (NULL);
     GtkWidget *frame2 = gtk_frame_new (NULL);
     gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
     gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);

     gtk_widget_set_size_request (hpaned, 200 + GTK_PANED (hpaned)->gutter_size, -1);

     gtk_paned_pack1 (GTK_PANED (hpaned), frame1, TRUE, FALSE);
     gtk_widget_set_size_request (frame1, 50, -1);

     gtk_paned_pack2 (GTK_PANED (hpaned), frame2, FALSE, FALSE);
     gtk_widget_set_size_request (frame2, 50, -1);

137.2 Usage
===========

 -- Class: <gtk-paned>
     Derives from `<gtk-container>'.

     This class defines the following properties:

    `position'
          Position of paned separator in pixels (0 means all the way to
          the left/top)

    `position-set'
          TRUE if the Position property should be used

    `min-position'
          Smallest possible value for the "position" property

    `max-position'
          Largest possible value for the "position" property



 -- Signal on <gtk-paned>: cycle-child-focus (arg0 `<gboolean>')
          => `<gboolean>'

 -- Signal on <gtk-paned>: toggle-handle-focus => `<gboolean>'

 -- Signal on <gtk-paned>: move-handle (arg0 `<gtk-scroll-type>')
          => `<gboolean>'

 -- Signal on <gtk-paned>: cycle-handle-focus (arg0 `<gboolean>')
          => `<gboolean>'

 -- Signal on <gtk-paned>: accept-position => `<gboolean>'

 -- Signal on <gtk-paned>: cancel-position => `<gboolean>'

 -- Function: gtk-paned-add1 (self `<gtk-paned>') (child `<gtk-widget>')
 -- Method: add1
     Adds a child to the top or left pane with default parameters. This
     is equivalent to `gtk_paned_pack1 (paned, child, FALSE, TRUE)'.

    PANED
          a paned widget

    CHILD
          the child to add



 -- Function: gtk-paned-add2 (self `<gtk-paned>') (child `<gtk-widget>')
 -- Method: add2
     Adds a child to the bottom or right pane with default parameters.
     This is equivalent to `gtk_paned_pack2 (paned, child, TRUE, TRUE)'.

    PANED
          a paned widget

    CHILD
          the child to add



 -- Function: gtk-paned-pack1 (self `<gtk-paned>')
          (child `<gtk-widget>') (resize `bool') (shrink `bool')
 -- Method: pack1
     Adds a child to the top or left pane.

    PANED
          a paned widget

    CHILD
          the child to add

    RESIZE
          should this child expand when the paned widget is resized.

    SHRINK
          can this child be made smaller than its requisition.



 -- Function: gtk-paned-pack2 (self `<gtk-paned>')
          (child `<gtk-widget>') (resize `bool') (shrink `bool')
 -- Method: pack2
     Adds a child to the bottom or right pane.

    PANED
          a paned widget

    CHILD
          the child to add

    RESIZE
          should this child expand when the paned widget is resized.

    SHRINK
          can this child be made smaller than its requisition.



 -- Function: gtk-paned-get-child1 (self `<gtk-paned>') => 
          (ret `<gtk-widget>')
 -- Method: get-child1
     Obtains the first child of the paned widget.

    PANED
          a `<gtk-paned>' widget

    RET
          first child, or ``#f'' if it is not set.


     Since 2.4


 -- Function: gtk-paned-get-child2 (self `<gtk-paned>') => 
          (ret `<gtk-widget>')
 -- Method: get-child2
     Obtains the second child of the paned widget.

    PANED
          a `<gtk-paned>' widget

    RET
          second child, or ``#f'' if it is not set.


     Since 2.4


 -- Function: gtk-paned-set-position (self `<gtk-paned>')
          (position `int')
 -- Method: set-position
     Sets the position of the divider between the two panes.

    PANED
          a `<gtk-paned>' widget

    POSITION
          pixel position of divider, a negative value means that the
          position is unset.



 -- Function: gtk-paned-get-position (self `<gtk-paned>') => 
          (ret `int')
 -- Method: get-position
     Obtains the position of the divider between the two panes.

    PANED
          a `<gtk-paned>' widget

    RET
          position of the divider




File: guile-gnome-gtk.info,  Node: GtkRange,  Next: GtkScale,  Prev: GtkPaned,  Up: Top

138 GtkRange
************

Base class for widgets which visualize an adjustment

138.1 Overview
==============

138.2 Usage
===========

 -- Class: <gtk-range>
     Derives from `<gtk-widget>'.

     This class defines the following properties:

    `update-policy'
          How the range should be updated on the screen

    `adjustment'
          The GtkAdjustment that contains the current value of this
          range object

    `inverted'
          Invert direction slider moves to increase range value

    `lower-stepper-sensitivity'
          The sensitivity policy for the stepper that points to the
          adjustment's lower side

    `upper-stepper-sensitivity'
          The sensitivity policy for the stepper that points to the
          adjustment's upper side

    `show-fill-level'
          Whether to display a fill level indicator graphics on trough.

    `restrict-to-fill-level'
          Whether to restrict the upper boundary to the fill level.

    `fill-level'
          The fill level.



 -- Signal on <gtk-range>: value-changed
     Emitted when the range value changes.


 -- Signal on <gtk-range>: adjust-bounds (arg0 `<gdouble>')

 -- Signal on <gtk-range>: move-slider (arg0 `<gtk-scroll-type>')
     Virtual function that moves the slider. Used for keybindings.


 -- Signal on <gtk-range>: change-value (arg0 `<gtk-scroll-type>')
          (arg1 `<gdouble>') => `<gboolean>'
     The ::change-value signal is emitted when a scroll action is
     performed on a range. It allows an application to determine the
     type of scroll event that occurred and the resultant new value.
     The application can handle the event itself and return ``#t'' to
     prevent further processing. Or, by returning ``#f'', it can pass
     the event to other handlers until the default GTK+ handler is
     reached.

     The value parameter is unrounded. An application that overrides the
     ::change-value signal is responsible for clamping the value to the
     desired number of decimal digits; the default GTK+ handler clamps
     the value based on RANGE->ROUND-DIGITS.

     It is not possible to use delayed update policies in an overridden
     ::change-value handler.

     Since 2.6


 -- Function: gtk-range-get-adjustment (self `<gtk-range>') => 
          (ret `<gtk-adjustment>')
 -- Method: get-adjustment
     Get the `<gtk-adjustment>' which is the "model" object for
     `<gtk-range>'. See `gtk-range-set-adjustment' for details. The
     return value does not have a reference added, so should not be
     unreferenced.

    RANGE
          a `<gtk-range>'

    RET
          a `<gtk-adjustment>'



 -- Function: gtk-range-set-update-policy (self `<gtk-range>')
          (policy `<gtk-update-type>')
 -- Method: set-update-policy
     Sets the update policy for the range. `<gtk-update-continuous>'
     means that anytime the range slider is moved, the range value will
     change and the value_changed signal will be emitted.
     `<gtk-update-delayed>' means that the value will be updated after
     a brief timeout where no slider motion occurs, so updates are
     spaced by a short time rather than continuous.
     `<gtk-update-discontinuous>' means that the value will only be
     updated when the user releases the button and ends the slider drag
     operation.

    RANGE
          a `<gtk-range>'

    POLICY
          update policy



 -- Function: gtk-range-set-adjustment (self `<gtk-range>')
          (adjustment `<gtk-adjustment>')
 -- Method: set-adjustment
     Sets the adjustment to be used as the "model" object for this
     range widget. The adjustment indicates the current range value,
     the minimum and maximum range values, the step/page increments
     used for keybindings and scrolling, and the page size. The page
     size is normally 0 for `<gtk-scale>' and nonzero for
     `<gtk-scrollbar>', and indicates the size of the visible area of
     the widget being scrolled. The page size affects the size of the
     scrollbar slider.

    RANGE
          a `<gtk-range>'

    ADJUSTMENT
          a `<gtk-adjustment>'



 -- Function: gtk-range-get-inverted (self `<gtk-range>') => 
          (ret `bool')
 -- Method: get-inverted
     Gets the value set by `gtk-range-set-inverted'.

    RANGE
          a `<gtk-range>'

    RET
          ``#t'' if the range is inverted



 -- Function: gtk-range-set-inverted (self `<gtk-range>')
          (setting `bool')
 -- Method: set-inverted
     Ranges normally move from lower to higher values as the slider
     moves from top to bottom or left to right. Inverted ranges have
     higher values at the top or on the right rather than on the bottom
     or left.

    RANGE
          a `<gtk-range>'

    SETTING
          ``#t'' to invert the range



 -- Function: gtk-range-get-update-policy (self `<gtk-range>') => 
          (ret `<gtk-update-type>')
 -- Method: get-update-policy
     Gets the update policy of RANGE. See `gtk-range-set-update-policy'.

    RANGE
          a `<gtk-range>'

    RET
          the current update policy



 -- Function: gtk-range-get-value (self `<gtk-range>') => 
          (ret `double')
 -- Method: get-value
     Gets the current value of the range.

    RANGE
          a `<gtk-range>'

    RET
          current value of the range.



 -- Function: gtk-range-set-increments (self `<gtk-range>')
          (step `double') (page `double')
 -- Method: set-increments
     Sets the step and page sizes for the range. The step size is used
     when the user clicks the `<gtk-scrollbar>' arrows or moves
     `<gtk-scale>' via arrow keys. The page size is used for example
     when moving via Page Up or Page Down keys.

    RANGE
          a `<gtk-range>'

    STEP
          step size

    PAGE
          page size



 -- Function: gtk-range-set-range (self `<gtk-range>') (min `double')
          (max `double')
 -- Method: set-range
     Sets the allowable values in the `<gtk-range>', and clamps the
     range value to be between MIN and MAX. (If the range has a
     non-zero page size, it is clamped between MIN and MAX - page-size.)

    RANGE
          a `<gtk-range>'

    MIN
          minimum range value

    MAX
          maximum range value



 -- Function: gtk-range-set-value (self `<gtk-range>') (value `double')
 -- Method: set-value
     Sets the current value of the range; if the value is outside the
     minimum or maximum range values, it will be clamped to fit inside
     them. The range emits the "value_changed" signal if the value
     changes.

    RANGE
          a `<gtk-range>'

    VALUE
          new value of the range




File: guile-gnome-gtk.info,  Node: GtkScale,  Next: GtkScrollbar,  Prev: GtkRange,  Up: Top

139 GtkScale
************

Base class for GtkHScale and GtkVScale

139.1 Overview
==============

A `<gtk-scale>' is a slider control used to select a numeric value. To
use it, you'll probably want to investigate the methods on its base
class, `<gtk-range>', in addition to the methods for `<gtk-scale>'
itself. To set the value of a scale, you would normally use
`gtk-range-set-value'. To detect changes to the value, you would
normally use the "value_changed" signal.

   The `<gtk-scale>' widget is an abstract class, used only for
deriving the subclasses `<gtk-hscale>' and `<gtk-vscale>'. To create a
scale widget, call `gtk-hscale-new-with-range' or
`gtk-vscale-new-with-range'.

139.2 Usage
===========

 -- Class: <gtk-scale>
     Derives from `<gtk-range>'.

     This class defines the following properties:

    `digits'
          The number of decimal places that are displayed in the value

    `draw-value'
          Whether the current value is displayed as a string next to
          the slider

    `value-pos'
          The position in which the current value is displayed



 -- Signal on <gtk-scale>: format-value (arg0 `<gdouble>')
          => `<gchararray>'
     Signal which allows you to change how the scale value is
     displayed. Connect a signal handler which returns an allocated
     string representing VALUE. That string will then be used to
     display the scale's value. Here's an example signal handler which
     displays a value 1.0 as with "->1.0<-".


          static gchar*
          format_value_callback (GtkScale *scale,
                                 gdouble   value)
          {
            return g_strdup_printf ("-->%0.*g<--",
                                    gtk_scale_get_digits (scale), value);
          }


 -- Function: gtk-scale-set-digits (self `<gtk-scale>') (digits `int')
 -- Method: set-digits
     Sets the number of decimal places that are displayed in the value.
     Also causes the value of the adjustment to be rounded off to this
     number of digits, so the retrieved value matches the value the
     user saw.

    SCALE
          a `<gtk-scale>'.

    DIGITS
          the number of decimal places to display, e.g. use 1 to
          display 1.0, 2 to display 1.00 etc.



 -- Function: gtk-scale-set-draw-value (self `<gtk-scale>')
          (draw_value `bool')
 -- Method: set-draw-value
     Specifies whether the current value is displayed as a string next
     to the slider.

    SCALE
          a `<gtk-scale>'.

    DRAW-VALUE
          a boolean.



 -- Function: gtk-scale-set-value-pos (self `<gtk-scale>')
          (pos `<gtk-position-type>')
 -- Method: set-value-pos
     Sets the position in which the current value is displayed.

    SCALE
          a `<gtk-scale>'.

    POS
          the position in which the current value is displayed.



 -- Function: gtk-scale-get-digits (self `<gtk-scale>') =>  (ret `int')
 -- Method: get-digits
     Gets the number of decimal places that are displayed in the value.

    SCALE
          a `<gtk-scale>'.

    RET
          the number of decimal places that are displayed.



 -- Function: gtk-scale-get-draw-value (self `<gtk-scale>') => 
          (ret `bool')
 -- Method: get-draw-value
     Returns whether the current value is displayed as a string next to
     the slider.

    SCALE
          a `<gtk-scale>'.

    RET
          whether the current value is displayed as a string.



 -- Function: gtk-scale-get-value-pos (self `<gtk-scale>') => 
          (ret `<gtk-position-type>')
 -- Method: get-value-pos
     Gets the position in which the current value is displayed.

    SCALE
          a `<gtk-scale>'.

    RET
          the position in which the current value is displayed.



 -- Function: gtk-scale-get-layout (self `<gtk-scale>') => 
          (ret `<pango-layout>')
 -- Method: get-layout
     Gets the `<pango-layout>' used to display the scale. The returned
     object is owned by the scale so does not need to be freed by the
     caller.

    SCALE
          A `<gtk-scale>'

    RET
          the `<pango-layout>' for this scale, or ``#f'' if the
          draw_value property is ``#f''.


     Since 2.4


 -- Function: gtk-scale-get-layout-offsets (self `<gtk-scale>') => 
          (x `int') (y `int')
 -- Method: get-layout-offsets
     Obtains the coordinates where the scale will draw the
     `<pango-layout>' representing the text in the scale. Remember when
     using the `<pango-layout>' function you need to convert to and
     from pixels using `pango-pixels' or `<pango-scale>'.

     If the draw_value property is ``#f'', the return values are
     undefined.

    SCALE
          a `<gtk-scale>'

    X
          location to store X offset of layout, or ``#f''

    Y
          location to store Y offset of layout, or ``#f''


     Since 2.4



File: guile-gnome-gtk.info,  Node: GtkScrollbar,  Next: GtkSeparator,  Prev: GtkScale,  Up: Top

140 GtkScrollbar
****************

Base class for GtkHScrollbar and GtkVScrollbar

140.1 Overview
==============

The `<gtk-scrollbar>' widget is an abstract base class for
`<gtk-hscrollbar>' and `<gtk-vscrollbar>'. It is not very useful in
itself.

   The position of the thumb in a scrollbar is controlled by the scroll
adjustments. See `<gtk-adjustment>' for the fields in an adjustment -
for `<gtk-scrollbar>', the "value" field represents the position of the
scrollbar, which must be between the "lower" field and "upper -
page_size." The "page_size" field represents the size of the visible
scrollable area. The "step_increment" and "page_increment" fields are
used when the user asks to step down (using the small stepper arrows)
or page down (using for example the PageDown key).

140.2 Usage
===========

 -- Class: <gtk-scrollbar>
     Derives from `<gtk-range>'.

     This class defines no properties, other than those defined by its
     superclasses.



File: guile-gnome-gtk.info,  Node: GtkSeparator,  Next: GtkWidget,  Prev: GtkScrollbar,  Up: Top

141 GtkSeparator
****************

Base class for and

141.1 Overview
==============

The `<gtk-separator>' widget is an abstract class, used only for
deriving the subclasses `<gtk-hseparator>' and `<gtk-vseparator>'.

141.2 Usage
===========

 -- Class: <gtk-separator>
     Derives from `<gtk-widget>'.

     This class defines no properties, other than those defined by its
     superclasses.



File: guile-gnome-gtk.info,  Node: GtkWidget,  Next: GtkIMContext,  Prev: GtkSeparator,  Up: Top

142 GtkWidget
*************

Base class for all widgets

142.1 Overview
==============

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 `gtk-widget-class-install-style-property' to install style
properties for a widget class, `gtk-widget-class-find-style-property' or
`gtk-widget-class-list-style-properties' to get information about
existing style properties and `gtk-widget-style-get-property',
`gtk-widget-style-get' or `gtk-widget-style-get-valist' to obtain the
value of a style property.

142.2 Usage
===========

 -- Class: <gtk-widget>
     Derives from `<atk-implementor-iface>', `<gtk-buildable>',
     `<gtk-object>'.

     This class defines the following properties:

    `name'
          The name of the widget

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

    `width-request'
          Override for width request of the widget, or -1 if natural
          request should be used

    `height-request'
          Override for height request of the widget, or -1 if natural
          request should be used

    `visible'
          Whether the widget is visible

    `sensitive'
          Whether the widget responds to input

    `app-paintable'
          Whether the application will paint directly on the widget

    `can-focus'
          Whether the widget can accept the input focus

    `has-focus'
          Whether the widget has the input focus

    `is-focus'
          Whether the widget is the focus widget within the toplevel

    `can-default'
          Whether the widget can be the default widget

    `has-default'
          Whether the widget is the default widget

    `receives-default'
          If TRUE, the widget will receive the default action when it
          is focused

    `composite-child'
          Whether the widget is part of a composite widget

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

    `events'
          The event mask that decides what kind of GdkEvents this
          widget gets

    `extension-events'
          The mask that decides what kind of extension events this
          widget gets

    `no-show-all'
          Whether gtk_widget_show_all() should not affect this widget

    `has-tooltip'
          Whether this widget has a tooltip

    `tooltip-markup'
          The contents of the tooltip for this widget

    `tooltip-text'
          The contents of the tooltip for this widget



 -- Signal on <gtk-widget>: composited-changed

 -- Signal on <gtk-widget>: show

 -- Signal on <gtk-widget>: hide

 -- Signal on <gtk-widget>: map

 -- Signal on <gtk-widget>: unmap

 -- Signal on <gtk-widget>: realize

 -- Signal on <gtk-widget>: unrealize

 -- Signal on <gtk-widget>: size-request (arg0 `<gtk-requisition>')

 -- Signal on <gtk-widget>: size-allocate (arg0 `<gdk-rectangle>')

 -- Signal on <gtk-widget>: state-changed (arg0 `<gtk-state-type>')

 -- Signal on <gtk-widget>: parent-set (arg0 `<gtk-widget>')
     The parent-set signal is emitted when a new parent has been set on
     a widget.


 -- Signal on <gtk-widget>: hierarchy-changed (arg0 `<gtk-widget>')
     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 `<gtk-window>'. This signal is emitted when a widget
     changes from un-anchored to anchored or vice-versa.


 -- Signal on <gtk-widget>: style-set (arg0 `<gtk-style>')
     The style-set signal is emitted when a new style has been set on a
     widget. Note that style-modifying functions like
     `gtk-widget-modify-base' also cause this signal to be emitted.


 -- Signal on <gtk-widget>: direction-changed
          (arg0 `<gtk-text-direction>')

 -- Signal on <gtk-widget>: grab-notify (arg0 `<gboolean>')
     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 `gtk-grab-add' when the topmost grab
     widget in the grab stack of its window group is not its ancestor.


 -- Signal on <gtk-widget>: child-notify (arg0 `<gparam>')
     The ::child-notify signal is emitted for each child property that
     has changed on an object. The signal's detail holds the property
     name.


 -- Signal on <gtk-widget>: mnemonic-activate (arg0 `<gboolean>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: grab-focus

 -- Signal on <gtk-widget>: focus (arg0 `<gtk-direction-type>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: move-focus (arg0 `<gtk-direction-type>')
     undocumented

 -- Signal on <gtk-widget>: event (arg0 `<gdk-event>') => `<gboolean>'

 -- Signal on <gtk-widget>: event-after (arg0 `<gdk-event>')

 -- Signal on <gtk-widget>: button-press-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: button-release-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: scroll-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: motion-notify-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: keynav-failed (arg0 `<gtk-direction-type>')
          => `<gboolean>'
     undocumented

 -- Signal on <gtk-widget>: delete-event (arg0 `<gdk-event>')
          => `<gboolean>'
     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 `gtk-widget-hide-on-delete' to
     this signal will cause the window to be hidden instead, so that it
     can later be shown again without reconstructing it.


 -- Signal on <gtk-widget>: destroy-event (arg0 `<gdk-event>')
          => `<gboolean>'
     The ::destroy-event signal is emitted when a `<gdk-window>' 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.


 -- Signal on <gtk-widget>: expose-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: key-press-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: key-release-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: enter-notify-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: leave-notify-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: configure-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: focus-in-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: focus-out-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: map-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: unmap-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: property-notify-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: selection-clear-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: selection-request-event
          (arg0 `<gdk-event>') => `<gboolean>'

 -- Signal on <gtk-widget>: selection-notify-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: selection-received
          (arg0 `<gtk-selection-data>') (arg1 `<guint>')

 -- Signal on <gtk-widget>: selection-get (arg0 `<gtk-selection-data>')
          (arg1 `<guint>') (arg2 `<guint>')

 -- Signal on <gtk-widget>: proximity-in-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: proximity-out-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: drag-leave (arg0 `<gdk-drag-context>')
          (arg1 `<guint>')
     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 `gtk-drag-unhighlight'


 -- Signal on <gtk-widget>: drag-begin (arg0 `<gdk-drag-context>')
     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 `gtk-drag-source-set-icon'.


 -- Signal on <gtk-widget>: drag-end (arg0 `<gdk-drag-context>')
     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.


 -- Signal on <gtk-widget>: drag-data-delete (arg0 `<gdk-drag-context>')
     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.


 -- Signal on <gtk-widget>: drag-failed (arg0 `<gdk-drag-context>')
          (arg1 `<gtk-drag-result>') => `<gboolean>'
     undocumented

 -- Signal on <gtk-widget>: drag-motion (arg0 `<gdk-drag-context>')
          (arg1 `<gint>') (arg2 `<gint>') (arg3 `<guint>')
          => `<gboolean>'
     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 ``#f'' and no further
     processing is necessary. Otherwise, the handler returns ``#t''. In
     this case, the handler is responsible for providing the necessary
     information for displaying feedback to the user, by calling
     `gdk-drag-status'. 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 `gtk-drag-get-data' and defer the
     `gdk-drag-status' 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 `gtk-drag-highlight'.


          static void
          drag_motion (GtkWidget *widget,
                	  GdkDragContext *context,
                       gint x,
                       gint y,
                       guint time)
          {
            GdkAtom target;

            PrivateData *private_data = GET_PRIVATE_DATA (widget);

            if (!private_data->drag_highlight)
             {
               private_data->drag_highlight = 1;
               gtk_drag_highlight (widget);
             }

            target = gtk_drag_dest_find_target (widget, context, NULL);
            if (target == GDK_NONE)
              gdk_drag_status (context, 0, time);
            else
             {
               private_data->pending_status = context->suggested_action;
               gtk_drag_get_data (widget, context, target, time);
             }

            return TRUE;
          }

          static void
          drag_data_received (GtkWidget        *widget,
                              GdkDragContext   *context,
                              gint              x,
                              gint              y,
                              GtkSelectionData *selection_data,
                              guint             info,
                              guint             time)
          {
            PrivateData *private_data = GET_PRIVATE_DATA (widget);

            if (private_data->suggested_action)
             {
               private_data->suggested_action = 0;

              /* 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 = gtk_selection_data_get_text (selection_data);
               if (!data_is_acceptable (str))
                 gdk_drag_status (context, 0, time);
               else
                 gdk_drag_status (context, private_data->suggested_action, time);
             }
            else
             {
               /* accept the drop */
             }
          }


 -- Signal on <gtk-widget>: drag-drop (arg0 `<gdk-drag-context>')
          (arg1 `<gint>') (arg2 `<gint>') (arg3 `<guint>')
          => `<gboolean>'
     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 ``#f'' and no further processing is
     necessary. Otherwise, the handler returns ``#t''. In this case,
     the handler must ensure that `gtk-drag-finish' is called to let
     the source know that the drop is done.  The call to
     `gtk-drag-finish' 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.


 -- Signal on <gtk-widget>: drag-data-get (arg0 `<gdk-drag-context>')
          (arg1 `<gtk-selection-data>') (arg2 `<guint>')
          (arg3 `<guint>')
     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
     `gtk-selection-data-set' and `gtk-selection-data-set-text'.


 -- Signal on <gtk-widget>: drag-data-received
          (arg0 `<gdk-drag-context>') (arg1 `<gint>') (arg2 `<gint>')
          (arg3 `<gtk-selection-data>') (arg4 `<guint>')
          (arg5 `<guint>')
     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 `gdk-drag-status' 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
     `gtk-drag-finish', setting the SUCCESS parameter depending on
     whether the data was processed successfully.

     The handler may inspect and modify DRAG-CONTEXT->ACTION before
     calling `gtk-drag-finish', e.g. to implement `GDK_ACTION_ASK' as
     shown in the following example:


          void
          drag_data_received (GtkWidget          *widget,
                              GdkDragContext     *drag_context,
                              gint                x,
                              gint                y,
                              GtkSelectionData   *data,
                              guint               info,
                              guint               time)
          {
            if ((data->length >= 0) && (data->format == 8))
              {
                if (drag_context->action == GDK_ACTION_ASK)
                  {
                    GtkWidget *dialog;
                    gint response;

                    dialog = gtk_message_dialog_new (NULL,
                                                     GTK_DIALOG_MODAL |
                                                     GTK_DIALOG_DESTROY_WITH_PARENT,
                                                     GTK_MESSAGE_INFO,
                                                     GTK_BUTTONS_YES_NO,
                                                     "Move the data ?\n");
                    response = gtk_dialog_run (GTK_DIALOG (dialog));
                    gtk_widget_destroy (dialog);

                    if (response == GTK_RESPONSE_YES)
                      drag_context->action = GDK_ACTION_MOVE;
                    else
                      drag_context->action = GDK_ACTION_COPY;
                   }

                gtk_drag_finish (drag_context, TRUE, FALSE, time);
                return;
              }

             gtk_drag_finish (drag_context, FALSE, FALSE, time);
           }


 -- Signal on <gtk-widget>: visibility-notify-event
          (arg0 `<gdk-event>') => `<gboolean>'

 -- Signal on <gtk-widget>: client-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: no-expose-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: window-state-event (arg0 `<gdk-event>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: grab-broken-event (arg0 `<gdk-event>')
          => `<gboolean>'
     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


 -- Signal on <gtk-widget>: query-tooltip (arg0 `<gint>')
          (arg1 `<gint>') (arg2 `<gboolean>') (arg3 `<gtk-tooltip>')
          => `<gboolean>'
     undocumented

 -- Signal on <gtk-widget>: popup-menu => `<gboolean>'
     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 `<gtk-entry>' widget creates a menu with clipboard
     commands. See _(the missing figure, checklist-popup-menu_ for an
     example of how to use this signal.


 -- Signal on <gtk-widget>: show-help (arg0 `<gtk-widget-help-type>')
          => `<gboolean>'

 -- Signal on <gtk-widget>: accel-closures-changed

 -- Signal on <gtk-widget>: screen-changed (arg0 `<gdk-screen>')

 -- Signal on <gtk-widget>: can-activate-accel (arg0 `<guint>')
          => `<gboolean>'
     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 `<gtk-widget>' handling for determining whether an
     accelerator can be activated.


 -- Class: <gtk-requisition>
     Derives from `<gboxed>'.


 -- Class: <gtk-selection-data>
     Derives from `<gboxed>'.


 -- Function: gtk-widget-destroy (self `<gtk-widget>')
 -- Method: destroy
     Destroys a widget. Equivalent to `gtk-object-destroy', except that
     you don't have to cast the widget to `<gtk-object>'. When a widget
     is destroyed, it will break any references it holds to other
     objects. If the widget is inside a container, the widget will be
     removed from the container. If the widget is a toplevel (derived
     from `<gtk-window>'), it will be removed from the list of
     toplevels, and the reference GTK+ holds to it will be removed.
     Removing a widget from its container or the list of toplevels
     results in the widget being finalized, unless you've added
     additional references to the widget with `g-object-ref'.

     In most cases, only toplevel widgets (windows) require explicit
     destruction, because when you destroy a toplevel its children will
     be destroyed as well.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-unparent (self `<gtk-widget>')
 -- Method: unparent
     This function is only for use in widget implementations. Should be
     called by implementations of the remove method on
     `<gtk-container>', to dissociate a child from the container.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-show (self `<gtk-widget>')
 -- Method: show
     Flags a widget to be displayed. Any widget that isn't shown will
     not appear on the screen. If you want to show all the widgets in a
     container, it's easier to call `gtk-widget-show-all' on the
     container, instead of individually showing the widgets.

     Remember that you have to show the containers containing a widget,
     in addition to the widget itself, before it will appear onscreen.

     When a toplevel container is shown, it is immediately realized and
     mapped; other shown widgets are realized and mapped when their
     toplevel container is realized and mapped.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-show-now (self `<gtk-widget>')
 -- Method: show-now
     Shows a widget. If the widget is an unmapped toplevel widget (i.e.
     a `<gtk-window>' that has not yet been shown), enter the main loop
     and wait for the window to actually be mapped. Be careful; because
     the main loop is running, anything can happen during this function.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-hide (self `<gtk-widget>')
 -- Method: hide
     Reverses the effects of `gtk-widget-show', causing the widget to
     be hidden (invisible to the user).

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-show-all (self `<gtk-widget>')
 -- Method: show-all
     Recursively shows a widget, and any child widgets (if the widget
     is a container).

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-hide-all (self `<gtk-widget>')
 -- Method: hide-all
     Recursively hides a widget and any child widgets.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-map (self `<gtk-widget>')
 -- Method: map
     This function is only for use in widget implementations. Causes a
     widget to be mapped if it isn't already.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-unmap (self `<gtk-widget>')
 -- Method: unmap
     This function is only for use in widget implementations. Causes a
     widget to be unmapped if it's currently mapped.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-realize (self `<gtk-widget>')
 -- Method: realize
     Creates the GDK (windowing system) resources associated with a
     widget. For example, WIDGET->WINDOW will be created when a widget
     is realized.  Normally realization happens implicitly; if you show
     a widget and all its parent containers, then the widget will be
     realized and mapped automatically.

     Realizing a widget requires all the widget's parent widgets to be
     realized; calling `gtk-widget-realize' realizes the widget's
     parents in addition to WIDGET itself. If a widget is not yet
     inside a toplevel window when you realize it, bad things will
     happen.

     This function is primarily used in widget implementations, and
     isn't very useful otherwise. Many times when you think you might
     need it, a better approach is to connect to a signal that will be
     called after the widget is realized automatically, such as
     "expose_event". Or simply `g-signal-connect-after' to the
     "realize" signal.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-unrealize (self `<gtk-widget>')
 -- Method: unrealize
     This function is only useful in widget implementations. Causes a
     widget to be unrealized (frees all GDK resources associated with
     the widget, such as WIDGET->WINDOW).

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-queue-draw (self `<gtk-widget>')
 -- Method: queue-draw
     Equivalent to calling `gtk-widget-queue-draw-area' for the entire
     area of a widget.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-queue-resize (self `<gtk-widget>')
 -- Method: queue-resize
     This function is only for use in widget implementations. Flags a
     widget to have its size renegotiated; should be called when a
     widget for some reason has a new size request. For example, when
     you change the text in a `<gtk-label>', `<gtk-label>' queues a
     resize to ensure there's enough space for the new text.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-queue-resize-no-redraw (self `<gtk-widget>')
 -- Method: queue-resize-no-redraw
     This function works like `gtk-widget-queue-resize', except that
     the widget is not invalidated.

    WIDGET
          a `<gtk-widget>'


     Since 2.4


 -- Function: gtk-widget-size-request (self `<gtk-widget>')
          (requisition `<gtk-requisition>')
 -- Method: size-request
     This function is typically used when implementing a
     `<gtk-container>' subclass. Obtains the preferred size of a
     widget. The container uses this information to arrange its child
     widgets and decide what size allocations to give them with
     `gtk-widget-size-allocate'.

     You can also call this function from an application, with some
     caveats. Most notably, getting a size request requires the widget
     to be associated with a screen, because font information may be
     needed. Multihead-aware applications should keep this in mind.

     Also remember that the size request is not necessarily the size a
     widget will actually be allocated.

     See also `gtk-widget-get-child-requisition'.

    WIDGET
          a `<gtk-widget>'

    REQUISITION
          a `<gtk-requisition>' to be filled in



 -- Function: gtk-widget-get-child-requisition (self `<gtk-widget>')
          (requisition `<gtk-requisition>')
 -- Method: get-child-requisition
     This function is only for use in widget implementations. Obtains
     WIDGET->REQUISITION, unless someone has forced a particular
     geometry on the widget (e.g. with `gtk-widget-set-usize'), in
     which case it returns that geometry instead of the widget's
     requisition.

     This function differs from `gtk-widget-size-request' in that it
     retrieves the last size request value from WIDGET->REQUISITION,
     while `gtk-widget-size-request' actually calls the "size_request"
     method on WIDGET to compute the size request and fill in
     WIDGET->REQUISITION, and only then returns WIDGET->REQUISITION.

     Because this function does not call the "size_request" method, it
     can only be used when you know that WIDGET->REQUISITION is
     up-to-date, that is, `gtk-widget-size-request' has been called
     since the last time a resize was queued. In general, only
     container implementations have this information; applications
     should use `gtk-widget-size-request'.

    WIDGET
          a `<gtk-widget>'

    REQUISITION
          a `<gtk-requisition>' to be filled in



 -- Function: gtk-widget-size-allocate (self `<gtk-widget>')
          (allocation `<gdk-rectangle>')
 -- Method: size-allocate
     This function is only used by `<gtk-container>' subclasses, to
     assign a size and position to their child widgets.

    WIDGET
          a `<gtk-widget>'

    ALLOCATION
          position and size to be allocated to WIDGET



 -- Function: gtk-widget-add-accelerator (self `<gtk-widget>')
          (accel_signal `mchars') (accel_group `<gtk-accel-group>')
          (accel_key `unsigned-int') (accel_mods `<gdk-modifier-type>')
          (accel_flags `<gtk-accel-flags>')
 -- Method: add-accelerator
     Installs an accelerator for this WIDGET in ACCEL-GROUP that causes
     ACCEL-SIGNAL to be emitted if the accelerator is activated. The
     ACCEL-GROUP needs to be added to the widget's toplevel via
     `gtk-window-add-accel-group', and the signal must be of type
     `G_RUN_ACTION'. Accelerators added through this function are not
     user changeable during runtime. If you want to support
     accelerators that can be changed by the user, use
     `gtk-accel-map-add-entry' and `gtk-widget-set-accel-path' or
     `gtk-menu-item-set-accel-path' instead.

    WIDGET
          widget to install an accelerator on

    ACCEL-SIGNAL
          widget signal to emit on accelerator activation

    ACCEL-GROUP
          accel group for this widget, added to its toplevel

    ACCEL-KEY
          GDK keyval of the accelerator

    ACCEL-MODS
          modifier key combination of the accelerator

    ACCEL-FLAGS
          flag accelerators, e.g. `GTK_ACCEL_VISIBLE'



 -- Function: gtk-widget-remove-accelerator (self `<gtk-widget>')
          (accel_group `<gtk-accel-group>') (accel_key `unsigned-int')
          (accel_mods `<gdk-modifier-type>') =>  (ret `bool')
 -- Method: remove-accelerator
     Removes an accelerator from WIDGET, previously installed with
     `gtk-widget-add-accelerator'.

    WIDGET
          widget to install an accelerator on

    ACCEL-GROUP
          accel group for this widget

    ACCEL-KEY
          GDK keyval of the accelerator

    ACCEL-MODS
          modifier key combination of the accelerator

    RET
          whether an accelerator was installed and could be removed



 -- Function: gtk-widget-set-accel-path (self `<gtk-widget>')
          (accel_path `mchars') (accel_group `<gtk-accel-group>')
 -- Method: set-accel-path
     Given an accelerator group, ACCEL-GROUP, and an accelerator path,
     ACCEL-PATH, sets up an accelerator in ACCEL-GROUP so whenever the
     key binding that is defined for ACCEL-PATH is pressed, WIDGET will
     be activated. This removes any accelerators (for any accelerator
     group) installed by previous calls to `gtk-widget-set-accel-path'.
     Associating accelerators with paths allows them to be modified by
     the user and the modifications to be saved for future use. (See
     `gtk-accel-map-save'.)

     This function is a low level function that would most likely be
     used by a menu creation system like `<gtk-item-factory>'. If you
     use `<gtk-item-factory>', setting up accelerator paths will be done
     automatically.

     Even when you you aren't using `<gtk-item-factory>', if you only
     want to set up accelerators on menu items
     `gtk-menu-item-set-accel-path' provides a somewhat more convenient
     interface.

    WIDGET
          a `<gtk-widget>'

    ACCEL-PATH
          path used to look up the accelerator

    ACCEL-GROUP
          a `<gtk-accel-group>'.



 -- Function: gtk-widget-list-accel-closures (self `<gtk-widget>') => 
          (ret `glist-of')
 -- Method: list-accel-closures
     Lists the closures used by WIDGET for accelerator group
     connections with `gtk-accel-group-connect-by-path' or
     `gtk-accel-group-connect'. The closures can be used to monitor
     accelerator changes on WIDGET, by connecting to the
     ::accel_changed signal of the `<gtk-accel-group>' of a closure
     which can be found out with `gtk-accel-group-from-accel-closure'.

    WIDGET
          widget to list accelerator closures for

    RET
          a newly allocated `<g-list>' of closures



 -- Function: gtk-widget-can-activate-accel (self `<gtk-widget>')
          (signal_id `unsigned-int') =>  (ret `bool')
 -- Method: can-activate-accel
     Determines whether an accelerator that activates the signal
     identified by SIGNAL-ID can currently be activated. This is done
     by emitting the GtkWidget::can-activate-accel signal on WIDGET; if
     the signal isn't overridden by a handler or in a derived widget,
     then the default check is that the widget must be sensitive, and
     the widget and all its ancestors mapped.

    WIDGET
          a `<gtk-widget>'

    SIGNAL-ID
          the ID of a signal installed on WIDGET

    RET
          ``#t'' if the accelerator can be activated.


     Since 2.4


 -- Function: gtk-widget-event (self `<gtk-widget>')
          (event `<gdk-event>') =>  (ret `bool')
 -- Method: event
     Rarely-used function. This function is used to emit the event
     signals on a widget (those signals should never be emitted without
     using this function to do so). If you want to synthesize an event
     though, don't use this function; instead, use `gtk-main-do-event'
     so the event will behave as if it were in the event queue. Don't
     synthesize expose events; instead, use
     `gdk-window-invalidate-rect' to invalidate a region of the window.

    WIDGET
          a `<gtk-widget>'

    EVENT
          a `<gdk-event>'

    RET
          return from the event signal emission (``#t'' if the event was
          handled)



 -- Function: gtk-widget-activate (self `<gtk-widget>') =>  (ret `bool')
 -- Method: activate
     For widgets that can be "activated" (buttons, menu items, etc.)
     this function activates them. Activation is what happens when you
     press Enter on a widget during key navigation. If WIDGET isn't
     activatable, the function returns ``#f''.

    WIDGET
          a `<gtk-widget>' that's activatable

    RET
          ``#t'' if the widget was activatable



 -- Function: gtk-widget-reparent (self `<gtk-widget>')
          (new_parent `<gtk-widget>')
 -- Method: reparent
     Moves a widget from one `<gtk-container>' to another, handling
     reference count issues to avoid destroying the widget.

    WIDGET
          a `<gtk-widget>'

    NEW-PARENT
          a `<gtk-container>' to move the widget into



 -- Function: gtk-widget-is-focus (self `<gtk-widget>') =>  (ret `bool')
 -- Method: is-focus
     Determines if the widget is the focus widget within its toplevel.
     (This does not mean that the `HAS_FOCUS' flag is necessarily set;
     `HAS_FOCUS' will only be set if the toplevel widget additionally
     has the global input focus.)

    WIDGET
          a `<gtk-widget>'

    RET
          ``#t'' if the widget is the focus widget.



 -- Function: gtk-widget-grab-focus (self `<gtk-widget>')
 -- Method: grab-focus
     Causes WIDGET to have the keyboard focus for the `<gtk-window>'
     it's inside. WIDGET must be a focusable widget, such as a
     `<gtk-entry>'; something like `<gtk-frame>' won't work. (More
     precisely, it must have the `GTK_CAN_FOCUS' flag set.)

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-grab-default (self `<gtk-widget>')
 -- Method: grab-default
     Causes WIDGET to become the default widget. WIDGET must have the
     `GTK_CAN_DEFAULT' flag set; typically you have to set this flag
     yourself by calling `GTK_WIDGET_SET_FLAGS (WIDGET,
     GTK_CAN_DEFAULT)'. The default widget is activated when the user
     presses Enter in a window. Default widgets must be activatable,
     that is, `gtk-widget-activate' should affect them.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-set-name (self `<gtk-widget>') (name `mchars')
 -- Method: set-name
     Widgets can be named, which allows you to refer to them from a
     gtkrc file. You can apply a style to widgets with a particular
     name in the gtkrc file. See the documentation for gtkrc files (on
     the same page as the docs for `<gtk-rc-style>').

     Note that widget names are separated by periods in paths (see
     `gtk-widget-path'), so names with embedded periods may cause
     confusion.

    WIDGET
          a `<gtk-widget>'

    NAME
          name for the widget



 -- Function: gtk-widget-get-name (self `<gtk-widget>') => 
          (ret `mchars')
 -- Method: get-name
     Retrieves the name of a widget. See `gtk-widget-set-name' for the
     significance of widget names.

    WIDGET
          a `<gtk-widget>'

    RET
          name of the widget. This string is owned by GTK+ and should
          not be modified or freed



 -- Function: gtk-widget-set-state (self `<gtk-widget>')
          (state `<gtk-state-type>')
 -- Method: set-state
     This function is for use in widget implementations. Sets the state
     of a widget (insensitive, prelighted, etc.) Usually you should set
     the state using wrapper functions such as
     `gtk-widget-set-sensitive'.

    WIDGET
          a `<gtk-widget>'

    STATE
          new state for WIDGET



 -- Function: gtk-widget-set-sensitive (self `<gtk-widget>')
          (sensitive `bool')
 -- Method: set-sensitive
     Sets the sensitivity of a widget. A widget is sensitive if the
     user can interact with it. Insensitive widgets are "grayed out"
     and the user can't interact with them. Insensitive widgets are
     known as "inactive", "disabled", or "ghosted" in some other
     toolkits.

    WIDGET
          a `<gtk-widget>'

    SENSITIVE
          ``#t'' to make the widget sensitive



 -- Function: gtk-widget-set-parent (self `<gtk-widget>')
          (parent `<gtk-widget>')
 -- Method: set-parent
     This function is useful only when implementing subclasses of
     `<gtk-container>'. Sets the container as the parent of WIDGET, and
     takes care of some details such as updating the state and style of
     the child to reflect its new location. The opposite function is
     `gtk-widget-unparent'.

    WIDGET
          a `<gtk-widget>'

    PARENT
          parent container



 -- Function: gtk-widget-set-parent-window (self `<gtk-widget>')
          (parent_window `<gdk-window>')
 -- Method: set-parent-window
     Sets a non default parent window for WIDGET.

    WIDGET
          a `<gtk-widget>'.

    PARENT-WINDOW
          the new parent window.



 -- Function: gtk-widget-get-parent-window (self `<gtk-widget>') => 
          (ret `<gdk-window>')
 -- Method: get-parent-window
     Gets WIDGET's parent window.

    WIDGET
          a `<gtk-widget>'.

    RET
          the parent window of WIDGET.



 -- Function: gtk-widget-set-events (self `<gtk-widget>')
          (events `<gdk-event-mask>')
 -- Method: set-events
     Sets the event mask (see `<gdk-event-mask>') for a widget. The
     event mask determines which events a widget will receive. Keep in
     mind that different widgets have different default event masks,
     and by changing the event mask you may disrupt a widget's
     functionality, so be careful. This function must be called while a
     widget is unrealized. Consider `gtk-widget-add-events' for widgets
     that are already realized, or if you want to preserve the existing
     event mask. This function can't be used with `<gtk-no-window>'
     widgets; to get events on those widgets, place them inside a
     `<gtk-event-box>' and receive events on the event box.

    WIDGET
          a `<gtk-widget>'

    EVENTS
          event mask



 -- Function: gtk-widget-add-events (self `<gtk-widget>')
          (events `<gdk-event-mask>')
 -- Method: add-events
     Adds the events in the bitfield EVENTS to the event mask for
     WIDGET.  See `gtk-widget-set-events' for details.

    WIDGET
          a `<gtk-widget>'

    EVENTS
          an event mask, see `<gdk-event-mask>'



 -- Function: gtk-widget-set-extension-events (self `<gtk-widget>')
          (mode `<gdk-extension-mode>')
 -- Method: set-extension-events
     Sets the extension events mask to MODE. See `<gdk-extension-mode>'
     and `gdk-input-set-extension-events'.

    WIDGET
          a `<gtk-widget>'

    MODE
          bitfield of extension events to receive



 -- Function: gtk-widget-get-extension-events (self `<gtk-widget>') => 
          (ret `<gdk-extension-mode>')
 -- Method: get-extension-events
     Retrieves the extension events the widget will receive; see
     `gdk-input-set-extension-events'.

    WIDGET
          a `<gtk-widget>'

    RET
          extension events for WIDGET



 -- Function: gtk-widget-get-toplevel (self `<gtk-widget>') => 
          (ret `<gtk-widget>')
 -- Method: get-toplevel
     This function returns the topmost widget in the container
     hierarchy WIDGET is a part of. If WIDGET has no parent widgets, it
     will be returned as the topmost widget. No reference will be added
     to the returned widget; it should not be unreferenced.

     Note the difference in behavior vs. `gtk-widget-get-ancestor';
     `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)' would return
     ``#f'' if WIDGET wasn't inside a toplevel window, and if the
     window was inside a `<gtk-window-derived>' widget which was in
     turn inside the toplevel `<gtk-window>'. While the second case may
     seem unlikely, it actually happens when a `<gtk-plug>' is embedded
     inside a `<gtk-socket>' within the same application.

     To reliably find the toplevel `<gtk-window>', use
     `gtk-widget-get-toplevel' and check if the `TOPLEVEL' flags is set
     on the result.


           GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
           if (GTK_WIDGET_TOPLEVEL (toplevel))
             {
               [ Perform action on toplevel. ]
             }

    WIDGET
          a `<gtk-widget>'

    RET
          the topmost ancestor of WIDGET, or WIDGET itself if there's no
          ancestor.



 -- Function: gtk-widget-get-ancestor (self `<gtk-widget>')
          (widget_type `<gtype>') =>  (ret `<gtk-widget>')
 -- Method: get-ancestor
     Gets the first ancestor of WIDGET with type WIDGET-TYPE. For
     example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)' gets the
     first `<gtk-box>' that's an ancestor of WIDGET. No reference will
     be added to the returned widget; it should not be unreferenced.
     See note about checking for a toplevel `<gtk-window>' in the docs
     for `gtk-widget-get-toplevel'.

     Note that unlike `gtk-widget-is-ancestor',
     `gtk-widget-get-ancestor' considers WIDGET to be an ancestor of
     itself.

    WIDGET
          a `<gtk-widget>'

    WIDGET-TYPE
          ancestor type

    RET
          the ancestor widget, or ``#f'' if not found



 -- Function: gtk-widget-get-colormap (self `<gtk-widget>') => 
          (ret `<gdk-colormap>')
 -- Method: get-colormap
     Gets the colormap that will be used to render WIDGET. No reference
     will be added to the returned colormap; it should not be
     unreferenced.

    WIDGET
          a `<gtk-widget>'

    RET
          the colormap used by WIDGET



 -- Function: gtk-widget-set-colormap (self `<gtk-widget>')
          (colormap `<gdk-colormap>')
 -- Method: set-colormap
     Sets the colormap for the widget to the given value. Widget must
     not have been previously realized. This probably should only be
     used from an ``init'' function (i.e. from the constructor for the
     widget).

    WIDGET
          a `<gtk-widget>'

    COLORMAP
          a colormap



 -- Function: gtk-widget-get-visual (self `<gtk-widget>') => 
          (ret `<gdk-visual>')
 -- Method: get-visual
     Gets the visual that will be used to render WIDGET.

    WIDGET
          a `<gtk-widget>'

    RET
          the visual for WIDGET



 -- Function: gtk-widget-get-events (self `<gtk-widget>') => 
          (ret `int')
 -- Method: get-events
     Returns the event mask for the widget (a bitfield containing flags
     from the `<gdk-event-mask>' enumeration). These are the events
     that the widget will receive.

    WIDGET
          a `<gtk-widget>'

    RET
          event mask for WIDGET



 -- Function: gtk-widget-get-pointer (self `<gtk-widget>') => 
          (x `int') (y `int')
 -- Method: get-pointer
     Obtains the location of the mouse pointer in widget coordinates.
     Widget coordinates are a bit odd; for historical reasons, they are
     defined as WIDGET->WINDOW coordinates for widgets that are not
     `<gtk-no-window>' widgets, and are relative to
     WIDGET->ALLOCATION.X, WIDGET->ALLOCATION.Y for widgets that are
     `<gtk-no-window>' widgets.

    WIDGET
          a `<gtk-widget>'

    X
          return location for the X coordinate, or ``#f''

    Y
          return location for the Y coordinate, or ``#f''



 -- Function: gtk-widget-is-ancestor (self `<gtk-widget>')
          (ancestor `<gtk-widget>') =>  (ret `bool')
 -- Method: is-ancestor
     Determines whether WIDGET is somewhere inside ANCESTOR, possibly
     with intermediate containers.

    WIDGET
          a `<gtk-widget>'

    ANCESTOR
          another `<gtk-widget>'

    RET
          ``#t'' if ANCESTOR contains WIDGET as a child, grandchild,
          great grandchild, etc.



 -- Function: gtk-widget-translate-coordinates (self `<gtk-widget>')
          (dest_widget `<gtk-widget>') (src_x `int') (src_y `int') => 
          (ret `bool') (dest_x `int') (dest_y `int')
 -- Method: translate-coordinates
     Translate coordinates relative to SRC-WIDGET's allocation to
     coordinates relative to DEST-WIDGET's allocations. In order to
     perform this operation, both widgets must be realized, and must
     share a common toplevel.

    SRC-WIDGET
          a `<gtk-widget>'

    DEST-WIDGET
          a `<gtk-widget>'

    SRC-X
          X position relative to SRC-WIDGET

    SRC-Y
          Y position relative to SRC-WIDGET

    DEST-X
          location to store X position relative to DEST-WIDGET

    DEST-Y
          location to store Y position relative to DEST-WIDGET

    RET
          ``#f'' if either widget was not realized, or there was no
          common ancestor. In this case, nothing is stored in *DEST-X
          and *DEST-Y.  Otherwise ``#t''.



 -- Function: gtk-widget-hide-on-delete (self `<gtk-widget>') => 
          (ret `bool')
 -- Method: hide-on-delete
     Utility function; intended to be connected to the "delete_event"
     signal on a `<gtk-window>'. The function calls `gtk-widget-hide'
     on its argument, then returns ``#t''. If connected to
     "delete_event", the result is that clicking the close button for a
     window (on the window frame, top right corner usually) will hide
     but not destroy the window. By default, GTK+ destroys windows when
     "delete_event" is received.

    WIDGET
          a `<gtk-widget>'

    RET
          ``#t''



 -- Function: gtk-widget-set-style (self `<gtk-widget>')
          (style `<gtk-style>')
 -- Method: set-style
     Sets the `<gtk-style>' for a widget (WIDGET->STYLE). You probably
     don't want to use this function; it interacts badly with themes,
     because themes work by replacing the `<gtk-style>'. Instead, use
     `gtk-widget-modify-style'.

    WIDGET
          a `<gtk-widget>'

    STYLE
          a `<gtk-style>', or ``#f'' to remove the effect of a previous
          `gtk-widget-set-style' and go back to the default style



 -- Function: gtk-widget-ensure-style (self `<gtk-widget>')
 -- Method: ensure-style
     Ensures that WIDGET has a style (WIDGET->STYLE). Not a very useful
     function; most of the time, if you want the style, the widget is
     realized, and realized widgets are guaranteed to have a style
     already.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-get-style (self `<gtk-widget>') => 
          (ret `<gtk-style>')
 -- Method: get-style
     Simply an accessor function that returns WIDGET->STYLE.

    WIDGET
          a `<gtk-widget>'

    RET
          the widget's `<gtk-style>'



 -- Function: gtk-widget-reset-rc-styles (self `<gtk-widget>')
 -- Method: reset-rc-styles
     Reset the styles of WIDGET and all descendents, so when they are
     looked up again, they get the correct values for the currently
     loaded RC file settings.

     This function is not useful for applications.

    WIDGET
          a `<gtk-widget>'.



 -- Function: gtk-widget-push-colormap (cmap `<gdk-colormap>')
     Pushes CMAP onto a global stack of colormaps; the topmost colormap
     on the stack will be used to create all widgets. Remove CMAP with
     `gtk-widget-pop-colormap'. There's little reason to use this
     function.

    CMAP
          a `<gdk-colormap>'



 -- Function: gtk-widget-pop-colormap
     Removes a colormap pushed with `gtk-widget-push-colormap'.


 -- Function: gtk-widget-set-default-colormap
          (colormap `<gdk-colormap>')
     Sets the default colormap to use when creating widgets.
     `gtk-widget-push-colormap' is a better function to use if you only
     want to affect a few widgets, rather than all widgets.

    COLORMAP
          a `<gdk-colormap>'



 -- Function: gtk-widget-get-default-style =>  (ret `<gtk-style>')
     Returns the default style used by all widgets initially.

    RET
          the default style. This `<gtk-style>' object is owned by GTK+
          and should not be modified or freed.



 -- Function: gtk-widget-get-default-colormap =>  (ret `<gdk-colormap>')
     Obtains the default colormap used to create widgets.

    RET
          default widget colormap



 -- Function: gtk-widget-get-default-visual =>  (ret `<gdk-visual>')
     Obtains the visual of the default colormap. Not really useful;
     used to be useful before `gdk-colormap-get-visual' existed.

    RET
          visual of the default colormap



 -- Function: gtk-widget-set-direction (self `<gtk-widget>')
          (dir `<gtk-text-direction>')
 -- Method: set-direction
     Sets the reading direction on a particular widget. This direction
     controls the primary direction for widgets containing text, and
     also the direction in which the children of a container are
     packed. The ability to set the direction is present in order so
     that correct localization into languages with right-to-left
     reading directions can be done. Generally, applications will let
     the default reading direction present, except for containers where
     the containers are arranged in an order that is explicitely visual
     rather than logical (such as buttons for text justification).

     If the direction is set to `GTK_TEXT_DIR_NONE', then the value set
     by `gtk-widget-set-default-direction' will be used.

    WIDGET
          a `<gtk-widget>'

    DIR
          the new direction



 -- Function: gtk-widget-get-direction (self `<gtk-widget>') => 
          (ret `<gtk-text-direction>')
 -- Method: get-direction
     Gets the reading direction for a particular widget. See
     `gtk-widget-set-direction'.

    WIDGET
          a `<gtk-widget>'

    RET
          the reading direction for the widget.



 -- Function: gtk-widget-set-default-direction
          (dir `<gtk-text-direction>')
     Sets the default reading direction for widgets where the direction
     has not been explicitly set by `gtk-widget-set-direction'.

    DIR
          the new default direction. This cannot be `GTK_TEXT_DIR_NONE'.



 -- Function: gtk-widget-get-default-direction => 
          (ret `<gtk-text-direction>')
     Obtains the current default reading direction. See
     `gtk-widget-set-default-direction'.

    RET
          the current default direction.



 -- Function: gtk-widget-shape-combine-mask (self `<gtk-widget>')
          (shape_mask `<gdk-drawable>') (offset_x `int')
          (offset_y `int')
 -- Method: shape-combine-mask
     Sets a shape for this widget's GDK window. This allows for
     transparent windows etc., see `gdk-window-shape-combine-mask' for
     more information.

    WIDGET
          a `<gtk-widget>'.

    SHAPE-MASK
          shape to be added, or ``#f'' to remove an existing shape.

    OFFSET-X
          X position of shape mask with respect to WINDOW.

    OFFSET-Y
          Y position of shape mask with respect to WINDOW.



 -- Function: gtk-widget-input-shape-combine-mask (self `<gtk-widget>')
          (shape_mask `<gdk-drawable>') (offset_x `int')
          (offset_y `int')
 -- Method: input-shape-combine-mask
     Sets an input shape for this widget's GDK window. This allows for
     windows which react to mouse click in a nonrectangular region, see
     `gdk-window-input-shape-combine-mask' for more information.

    WIDGET
          a `<gtk-widget>'.

    SHAPE-MASK
          shape to be added, or ``#f'' to remove an existing shape.

    OFFSET-X
          X position of shape mask with respect to WINDOW.

    OFFSET-Y
          Y position of shape mask with respect to WINDOW.


     Since 2.10


 -- Function: gtk-widget-path (self `<gtk-widget>') => 
          (path_length `unsigned-int') (path `mchars')
          (path_reversed `mchars')
 -- Method: path
     Obtains the full path to WIDGET. The path is simply the name of a
     widget and all its parents in the container hierarchy, separated
     by periods. The name of a widget comes from `gtk-widget-get-name'.
     Paths are used to apply styles to a widget in gtkrc configuration
     files. Widget names are the type of the widget by default (e.g.
     "GtkButton") or can be set to an application-specific value with
     `gtk-widget-set-name'. By setting the name of a widget, you allow
     users or theme authors to apply styles to that specific widget in
     their gtkrc file. PATH-REVERSED-P fills in the path in reverse
     order, i.e. starting with WIDGET's name instead of starting with
     the name of WIDGET's outermost ancestor.

    WIDGET
          a `<gtk-widget>'

    PATH-LENGTH
          location to store length of the path, or ``#f''

    PATH
          location to store allocated path string, or ``#f''

    PATH-REVERSED
          location to store allocated reverse path string, or ``#f''



 -- Function: gtk-widget-class-path (self `<gtk-widget>') => 
          (path_length `unsigned-int') (path `mchars')
          (path_reversed `mchars')
 -- Method: class-path
     Same as `gtk-widget-path', but always uses the name of a widget's
     type, never uses a custom name set with `gtk-widget-set-name'.

    WIDGET
          a `<gtk-widget>'

    PATH-LENGTH
          location to store the length of the class path, or ``#f''

    PATH
          location to store the class path as an allocated string, or
          ``#f''

    PATH-REVERSED
          location to store the reverse class path as an allocated
          string, or ``#f''



 -- Function: gtk-widget-get-composite-name (self `<gtk-widget>') => 
          (ret `mchars')
 -- Method: get-composite-name
     Obtains the composite name of a widget.

    WIDGET
          a `<gtk-widget>'.

    RET
          the composite name of WIDGET, or ``#f'' if WIDGET is not a
          composite child. The string should not be freed when it is no
          longer needed.



 -- Function: gtk-widget-modify-style (self `<gtk-widget>')
          (style `<gtk-rc-style>')
 -- Method: modify-style
     Modifies style values on the widget. Modifications made using this
     technique take precedence over style values set via an RC file,
     however, they will be overriden if a style is explicitely set on
     the widget using `gtk-widget-set-style'. The `<gtk-rc-style>'
     structure is designed so each field can either be set or unset, so
     it is possible, using this function, to modify some style values
     and leave the others unchanged.

     Note that modifications made with this function are not cumulative
     with previous calls to `gtk-widget-modify-style' or with such
     functions as `gtk-widget-modify-fg'. If you wish to retain
     previous values, you must first call
     `gtk-widget-get-modifier-style', make your modifications to the
     returned style, then call `gtk-widget-modify-style' with that
     style. On the other hand, if you first call
     `gtk-widget-modify-style', subsequent calls to such functions
     `gtk-widget-modify-fg' will have a cumulative effect with the
     initial modifications.

    WIDGET
          a `<gtk-widget>'

    STYLE
          the `<gtk-rc-style>' holding the style modifications



 -- Function: gtk-widget-get-modifier-style (self `<gtk-widget>') => 
          (ret `<gtk-rc-style>')
 -- Method: get-modifier-style
     Returns the current modifier style for the widget. (As set by
     `gtk-widget-modify-style'.) If no style has previously set, a new
     `<gtk-rc-style>' will be created with all values unset, and set as
     the modifier style for the widget. If you make changes to this rc
     style, you must call `gtk-widget-modify-style', passing in the
     returned rc style, to make sure that your changes take effect.

     Caution: passing the style back to `gtk-widget-modify-style' will
     normally end up destroying it, because `gtk-widget-modify-style'
     copies the passed-in style and sets the copy as the new modifier
     style, thus dropping any reference to the old modifier style. Add
     a reference to the modifier style if you want to keep it alive.

    WIDGET
          a `<gtk-widget>'

    RET
          the modifier style for the widget. This rc style is owned by
          the widget. If you want to keep a pointer to value this
          around, you must add a refcount using `g-object-ref'.



 -- Function: gtk-widget-modify-fg (self `<gtk-widget>')
          (state `<gtk-state-type>') (color `<gdk-color>')
 -- Method: modify-fg
     Sets the foreground color for a widget in a particular state. All
     other style values are left untouched. See also
     `gtk-widget-modify-style'.

    WIDGET
          a `<gtk-widget>'.

    STATE
          the state for which to set the foreground color.

    COLOR
          the color to assign (does not need to be allocated), or
          ``#f'' to undo the effect of previous calls to of
          `gtk-widget-modify-fg'.



 -- Function: gtk-widget-modify-bg (self `<gtk-widget>')
          (state `<gtk-state-type>') (color `<gdk-color>')
 -- Method: modify-bg
     Sets the background color for a widget in a particular state. All
     other style values are left untouched. See also
     `gtk-widget-modify-style'.

     Note that "no window" widgets (which have the `GTK_NO_WINDOW' flag
     set) draw on their parent container's window and thus may not draw
     any background themselves. This is the case for e.g.
     `<gtk-label>'. To modify the background of such widgets, you have
     to set the background color on their parent; if you want to set
     the background of a rectangular area around a label, try placing
     the label in a `<gtk-event-box>' widget and setting the background
     color on that.

    WIDGET
          a `<gtk-widget>'.

    STATE
          the state for which to set the background color.

    COLOR
          the color to assign (does not need to be allocated), or
          ``#f'' to undo the effect of previous calls to of
          `gtk-widget-modify-bg'.



 -- Function: gtk-widget-modify-text (self `<gtk-widget>')
          (state `<gtk-state-type>') (color `<gdk-color>')
 -- Method: modify-text
     Sets the text color for a widget in a particular state. All other
     style values are left untouched. The text color is the foreground
     color used along with the base color (see
     `gtk-widget-modify-base') for widgets such as `<gtk-entry>' and
     `<gtk-text-view>'. See also `gtk-widget-modify-style'.

    WIDGET
          a `<gtk-widget>'.

    STATE
          the state for which to set the text color.

    COLOR
          the color to assign (does not need to be allocated), or
          ``#f'' to undo the effect of previous calls to of
          `gtk-widget-modify-text'.



 -- Function: gtk-widget-modify-base (self `<gtk-widget>')
          (state `<gtk-state-type>') (color `<gdk-color>')
 -- Method: modify-base
     Sets the base color for a widget in a particular state. All other
     style values are left untouched. The base color is the background
     color used along with the text color (see
     `gtk-widget-modify-text') for widgets such as `<gtk-entry>' and
     `<gtk-text-view>'. See also `gtk-widget-modify-style'.

     Note that "no window" widgets (which have the `GTK_NO_WINDOW' flag
     set) draw on their parent container's window and thus may not draw
     any background themselves. This is the case for e.g.
     `<gtk-label>'. To modify the background of such widgets, you have
     to set the base color on their parent; if you want to set the
     background of a rectangular area around a label, try placing the
     label in a `<gtk-event-box>' widget and setting the base color on
     that.

    WIDGET
          a `<gtk-widget>'.

    STATE
          the state for which to set the base color.

    COLOR
          the color to assign (does not need to be allocated), or
          ``#f'' to undo the effect of previous calls to of
          `gtk-widget-modify-base'.



 -- Function: gtk-widget-modify-font (self `<gtk-widget>')
          (font_desc `<pango-font-description>')
 -- Method: modify-font
     Sets the font to use for a widget. All other style values are left
     untouched.  See also `gtk-widget-modify-style'.

    WIDGET
          a `<gtk-widget>'

    FONT-DESC
          the font description to use, or ``#f'' to undo the effect of
          previous calls to `gtk-widget-modify-font'.



 -- Function: gtk-widget-create-pango-context (self `<gtk-widget>') => 
          (ret `<pango-context>')
 -- Method: create-pango-context
     Creates a new `<pango-context>' with the appropriate font map, font
     description, and base direction for drawing text for this widget.
     See also `gtk-widget-get-pango-context'.

    WIDGET
          a `<gtk-widget>'

    RET
          the new `<pango-context>'



 -- Function: gtk-widget-get-pango-context (self `<gtk-widget>') => 
          (ret `<pango-context>')
 -- Method: get-pango-context
     Gets a `<pango-context>' with the appropriate font map, font
     description, and base direction for this widget. Unlike the
     context returned by `gtk-widget-create-pango-context', this
     context is owned by the widget (it can be used until the screen
     for the widget changes or the widget is removed from its
     toplevel), and will be updated to match any changes to the widget's
     attributes.

     If you create and keep a `<pango-layout>' using this context, you
     must deal with changes to the context by calling
     `pango-layout-context-changed' on the layout in response to the
     ::style-set and ::direction-changed signals for the widget.

    WIDGET
          a `<gtk-widget>'

    RET
          the `<pango-context>' for the widget.



 -- Function: gtk-widget-create-pango-layout (self `<gtk-widget>')
          (text `mchars') =>  (ret `<pango-layout>')
 -- Method: create-pango-layout
     Creates a new `<pango-layout>' with the appropriate font map, font
     description, and base direction for drawing text for this widget.

     If you keep a `<pango-layout>' created in this way around, in
     order to notify the layout of changes to the base direction or
     font of this widget, you must call `pango-layout-context-changed'
     in response to the ::style-set and ::direction-changed signals for
     the widget.

    WIDGET
          a `<gtk-widget>'

    TEXT
          text to set on the layout (can be ``#f'')

    RET
          the new `<pango-layout>'



 -- Function: gtk-widget-render-icon (self `<gtk-widget>')
          (stock_id `mchars') (size `<gtk-icon-size>')
          (detail `mchars') =>  (ret `<gdk-pixbuf>')
 -- Method: render-icon
     A convenience function that uses the theme engine and RC file
     settings for WIDGET to look up STOCK-ID and render it to a pixbuf.
     STOCK-ID should be a stock icon ID such as `<gtk-stock-open>' or
     `<gtk-stock-ok>'. SIZE should be a size such as
     `<gtk-icon-size-menu>'. DETAIL should be a string that identifies
     the widget or code doing the rendering, so that theme engines can
     special-case rendering for that widget or code.

     The pixels in the returned `<gdk-pixbuf>' are shared with the rest
     of the application and should not be modified. The pixbuf should
     be freed after use with `g-object-unref'.

    WIDGET
          a `<gtk-widget>'

    STOCK-ID
          a stock ID

    SIZE
          a stock size. A size of (GtkIconSize)-1 means render at the
          size of the source and don't scale (if there are multiple
          source sizes, GTK+ picks one of the available sizes).

    DETAIL
          render detail to pass to theme engine

    RET
          a new pixbuf, or ``#f'' if the stock ID wasn't known



 -- Function: gtk-widget-pop-composite-child
     Cancels the effect of a previous call to
     `gtk-widget-push-composite-child'.


 -- Function: gtk-widget-push-composite-child
     Makes all newly-created widgets as composite children until the
     corresponding `gtk-widget-pop-composite-child' call.

     A composite child is a child that's an implementation detail of
     the container it's inside and should not be visible to people
     using the container. Composite children aren't treated differently
     by GTK (but see `gtk-container-foreach' vs.
     `gtk-container-forall'), but e.g. GUI builders might want to treat
     them in a different way.

     Here is a simple example:


            gtk_widget_push_composite_child ();
            scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
            gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
            gtk_widget_pop_composite_child ();
            gtk_widget_set_parent (scrolled_window->hscrollbar,
                                   GTK_WIDGET (scrolled_window));
            g_object_ref (scrolled_window->hscrollbar);


 -- Function: gtk-widget-queue-draw-area (self `<gtk-widget>')
          (x `int') (y `int') (width `int') (height `int')
 -- Method: queue-draw-area
     Invalidates the rectangular area of WIDGET defined by X, Y, WIDTH
     and HEIGHT by calling `gdk-window-invalidate-rect' on the widget's
     window and all its child windows. Once the main loop becomes idle
     (after the current batch of events has been processed, roughly),
     the window will receive expose events for the union of all regions
     that have been invalidated.

     Normally you would only use this function in widget
     implementations. You might also use it, or
     `gdk-window-invalidate-rect' directly, to schedule a redraw of a
     `<gtk-drawing-area>' or some portion thereof.

     Frequently you can just call `gdk-window-invalidate-rect' or
     `gdk-window-invalidate-region' instead of this function. Those
     functions will invalidate only a single window, instead of the
     widget and all its children.

     The advantage of adding to the invalidated region compared to
     simply drawing immediately is efficiency; using an invalid region
     ensures that you only have to redraw one time.

    WIDGET
          a `<gtk-widget>'

    X
          x coordinate of upper-left corner of rectangle to redraw

    Y
          y coordinate of upper-left corner of rectangle to redraw

    WIDTH
          width of region to draw

    HEIGHT
          height of region to draw



 -- Function: gtk-widget-reset-shapes (self `<gtk-widget>')
 -- Method: reset-shapes
     Recursively resets the shape on this widget and its descendants.

    WIDGET
          a `<gtk-widget>'.



 -- Function: gtk-widget-set-app-paintable (self `<gtk-widget>')
          (app_paintable `bool')
 -- Method: set-app-paintable
     Sets whether the application intends to draw on the widget in an
     ::expose-event handler.

     This is a hint to the widget and does not affect the behavior of
     the GTK+ core; many widgets ignore this flag entirely. For widgets
     that do pay attention to the flag, such as `<gtk-event-box>' and
     `<gtk-window>', the effect is to suppress default themed drawing
     of the widget's background. (Children of the widget will still be
     drawn.) The application is then entirely responsible for drawing
     the widget background.

     Note that the background is still drawn when the widget is mapped.
     If this is not suitable (e.g. because you want to make a
     transparent window using an RGBA visual), you can work around this
     by doing:


           gtk_widget_realize (window);
           gdk_window_set_back_pixmap (window->window, NULL, FALSE);
           gtk_widget_show (window);

    WIDGET
          a `<gtk-widget>'

    APP-PAINTABLE
          ``#t'' if the application will paint on the widget



 -- Function: gtk-widget-set-double-buffered (self `<gtk-widget>')
          (double_buffered `bool')
 -- Method: set-double-buffered
     Widgets are double buffered by default; you can use this function
     to turn off the buffering. "Double buffered" simply means that
     `gdk-window-begin-paint-region' and `gdk-window-end-paint' are
     called automatically around expose events sent to the widget.
     `gdk-window-begin-paint' diverts all drawing to a widget's window
     to an offscreen buffer, and `gdk-window-end-paint' draws the
     buffer to the screen. The result is that users see the window
     update in one smooth step, and don't see individual graphics
     primitives being rendered.

     In very simple terms, double buffered widgets don't flicker, so
     you would only use this function to turn off double buffering if
     you had special needs and really knew what you were doing.

     Note: if you turn off double-buffering, you have to handle expose
     events, since even the clearing to the background color or pixmap
     will not happen automatically (as it is done in
     `gdk-window-begin-paint').

    WIDGET
          a `<gtk-widget>'

    DOUBLE-BUFFERED
          ``#t'' to double-buffer a widget



 -- Function: gtk-widget-set-redraw-on-allocate (self `<gtk-widget>')
          (redraw_on_allocate `bool')
 -- Method: set-redraw-on-allocate
     Sets whether the entire widget is queued for drawing when its size
     allocation changes. By default, this setting is ``#t'' and the
     entire widget is redrawn on every size change. If your widget
     leaves the upper left unchanged when made bigger, turning this
     setting on will improve performance.

     Note that for `NO_WINDOW' widgets setting this flag to ``#f''
     turns off all allocation on resizing: the widget will not even
     redraw if its position changes; this is to allow containers that
     don't draw anything to avoid excess invalidations. If you set this
     flag on a `NO_WINDOW' widget that _does_ draw on WIDGET->WINDOW,
     you are responsible for invalidating both the old and new
     allocation of the widget when the widget is moved and responsible
     for invalidating regions newly when the widget increases size.

    WIDGET
          a `<gtk-widget>'

    REDRAW-ON-ALLOCATE
          if ``#t'', the entire widget will be redrawn when it is
          allocated to a new size. Otherwise, only the new portion of
          the widget will be redrawn.



 -- Function: gtk-widget-set-composite-name (self `<gtk-widget>')
          (name `mchars')
 -- Method: set-composite-name
     Sets a widgets composite name. The widget must be a composite
     child of its parent; see `gtk-widget-push-composite-child'.

    WIDGET
          a `<gtk-widget>'.

    NAME
          the name to set.



 -- Function: gtk-widget-set-scroll-adjustments (self `<gtk-widget>')
          (hadjustment `<gtk-adjustment>')
          (vadjustment `<gtk-adjustment>') =>  (ret `bool')
 -- Method: set-scroll-adjustments
     For widgets that support scrolling, sets the scroll adjustments
     and returns ``#t''. For widgets that don't support scrolling, does
     nothing and returns ``#f''. Widgets that don't support scrolling
     can be scrolled by placing them in a `<gtk-viewport>', which does
     support scrolling.

    WIDGET
          a `<gtk-widget>'

    HADJUSTMENT
          an adjustment for horizontal scrolling, or ``#f''

    VADJUSTMENT
          an adjustment for vertical scrolling, or ``#f''

    RET
          ``#t'' if the widget supports scrolling



 -- Function: gtk-widget-mnemonic-activate (self `<gtk-widget>')
          (group_cycling `bool') =>  (ret `bool')
 -- Method: mnemonic-activate
    WIDGET

    GROUP-CYCLING

    RET


 -- Function: gtk-widget-region-intersect (self `<gtk-widget>')
          (region `<gdk-region>') =>  (ret `<gdk-region>')
 -- Method: region-intersect
     Computes the intersection of a WIDGET's area and REGION, returning
     the intersection. The result may be empty, use `gdk-region-empty'
     to check.

    WIDGET
          a `<gtk-widget>'

    REGION
          a `<gdk-region>', in the same coordinate system as
          WIDGET->ALLOCATION. That is, relative to WIDGET->WINDOW for
          `NO_WINDOW' widgets; relative to the parent window of
          WIDGET->WINDOW for widgets with their own window.

    RET
          A newly allocated region holding the intersection of WIDGET
          and REGION. The coordinates of the return value are relative
          to WIDGET->WINDOW for `NO_WINDOW' widgets, and relative to
          the parent window of WIDGET->WINDOW for widgets with their
          own window.



 -- Function: gtk-widget-send-expose (self `<gtk-widget>')
          (event `<gdk-event>') =>  (ret `int')
 -- Method: send-expose
     Very rarely-used function. This function is used to emit an expose
     event signals on a widget. This function is not normally used
     directly. The only time it is used is when propagating an expose
     event to a child `NO_WINDOW' widget, and that is normally done
     using `gtk-container-propagate-expose'.

     If you want to force an area of a window to be redrawn, use
     `gdk-window-invalidate-rect' or `gdk-window-invalidate-region'. To
     cause the redraw to be done immediately, follow that call with a
     call to `gdk-window-process-updates'.

    WIDGET
          a `<gtk-widget>'

    EVENT
          a expose `<gdk-event>'

    RET
          return from the event signal emission (``#t'' if the event was
          handled)



 -- Function: gtk-widget-style-get-property (self `<gtk-widget>')
          (property_name `mchars') (value `<gvalue>')
 -- Method: style-get-property
     Gets the value of a style property of WIDGET.

    WIDGET
          a `<gtk-widget>'

    PROPERTY-NAME
          the name of a style property

    VALUE
          location to return the property value



 -- Function: gtk-widget-get-accessible (self `<gtk-widget>') => 
          (ret `<atk-object>')
 -- Method: get-accessible
     Returns the accessible object that describes the widget to an
     assistive technology.

     If no accessibility library is loaded (i.e. no ATK implementation
     library is loaded via `GTK_MODULES' or via another application
     library, such as libgnome), then this `<atk-object>' instance may
     be a no-op. Likewise, if no class-specific `<atk-object>'
     implementation is available for the widget instance in question,
     it will inherit an `<atk-object>' implementation from the first
     ancestor class for which such an implementation is defined.

     The documentation of the ATK
     (http://developer.gnome.org/doc/API/2.0/atk/index.html) library
     contains more information about accessible objects and their uses.

    WIDGET
          a `<gtk-widget>'

    RET
          the `<atk-object>' associated with WIDGET



 -- Function: gtk-widget-child-focus (self `<gtk-widget>')
          (direction `<gtk-direction-type>') =>  (ret `bool')
 -- Method: child-focus
     This function is used by custom widget implementations; if you're
     writing an app, you'd use `gtk-widget-grab-focus' to move the
     focus to a particular widget, and `gtk-container-set-focus-chain'
     to change the focus tab order.  So you may want to investigate
     those functions instead.

     `gtk-widget-child-focus' is called by containers as the user moves
     around the window using keyboard shortcuts. DIRECTION indicates
     what kind of motion is taking place (up, down, left, right, tab
     forward, tab backward).  `gtk-widget-child-focus' invokes the
     "focus" signal on `<gtk-widget>'; widgets override the default
     handler for this signal in order to implement appropriate focus
     behavior.

     The "focus" default handler for a widget should return ``#t'' if
     moving in DIRECTION left the focus on a focusable location inside
     that widget, and ``#f'' if moving in DIRECTION moved the focus
     outside the widget. If returning ``#t'', widgets normally call
     `gtk-widget-grab-focus' to place the focus accordingly; if
     returning ``#f'', they don't modify the current focus location.

     This function replaces `gtk-container-focus' from GTK+ 1.2. It was
     necessary to check that the child was visible, sensitive, and
     focusable before calling `gtk-container-focus'.
     `gtk-widget-child-focus' returns ``#f'' if the widget is not
     currently in a focusable state, so there's no need for those
     checks.

    WIDGET
          a `<gtk-widget>'

    DIRECTION
          direction of focus movement

    RET
          ``#t'' if focus ended up inside WIDGET



 -- Function: gtk-widget-child-notify (self `<gtk-widget>')
          (child_property `mchars')
 -- Method: child-notify
     Emits a "child-notify" signal for the child propertyCHILD-PROPERTY
     on WIDGET.

     This is the analogue of `g-object-notify' for child properties.

    WIDGET
          a `<gtk-widget>'

    CHILD-PROPERTY
          the name of a child property installed on the class of
          WIDGET's parent.



 -- Function: gtk-widget-freeze-child-notify (self `<gtk-widget>')
 -- Method: freeze-child-notify
     Stops emission of "child-notify" signals on WIDGET. The signals
     are queued until `gtk-widget-thaw-child-notify' is called on
     WIDGET.

     This is the analogue of `g-object-freeze-notify' for child
     properties.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-get-child-visible (self `<gtk-widget>') => 
          (ret `bool')
 -- Method: get-child-visible
     Gets the value set with `gtk-widget-set-child-visible'. If you
     feel a need to use this function, your code probably needs
     reorganization.

     This function is only useful for container implementations and
     never should be called by an application.

    WIDGET
          a `<gtk-widget>'

    RET
          ``#t'' if the widget is mapped with the parent.



 -- Function: gtk-widget-get-parent (self `<gtk-widget>') => 
          (ret `<gtk-widget>')
 -- Method: get-parent
     Returns the parent container of WIDGET.

    WIDGET
          a `<gtk-widget>'

    RET
          the parent container of WIDGET, or ``#f''



 -- Function: gtk-widget-get-settings (self `<gtk-widget>') => 
          (ret `<gtk-settings>')
 -- Method: get-settings
     Gets the settings object holding the settings (global property
     settings, RC file information, etc) used for this widget.

     Note that this function can only be called when the `<gtk-widget>'
     is attached to a toplevel, since the settings object is specific
     to a particular `<gdk-screen>'.

    WIDGET
          a `<gtk-widget>'

    RET
          the relevant `<gtk-settings>' object



 -- Function: gtk-widget-get-clipboard (self `<gtk-widget>')
          (selection `<gdk-atom>') =>  (ret `<gtk-clipboard>')
 -- Method: get-clipboard
     Returns the clipboard object for the given selection to be used
     with WIDGET. WIDGET must have a `<gdk-display>' associated with it,
     so must be attached to a toplevel window.

    WIDGET
          a `<gtk-widget>'

    SELECTION
          a `<gdk-atom>' which identifies the clipboard to use.
          `GDK_SELECTION_CLIPBOARD' gives the default clipboard.
          Another common value is `GDK_SELECTION_PRIMARY', which gives
          the primary X selection.

    RET
          the appropriate clipboard object. If no clipboard already
          exists, a new one will be created. Once a clipboard object
          has been created, it is persistent for all time.


     Since 2.2


 -- Function: gtk-widget-get-display (self `<gtk-widget>') => 
          (ret `<gdk-display>')
 -- Method: get-display
     Get the `<gdk-display>' for the toplevel window associated with
     this widget. This function can only be called after the widget has
     been added to a widget hierarchy with a `<gtk-window>' at the top.

     In general, you should only create display specific resources when
     a widget has been realized, and you should free those resources
     when the widget is unrealized.

    WIDGET
          a `<gtk-widget>'

    RET
          the `<gdk-display>' for the toplevel for this widget.


     Since 2.2


 -- Function: gtk-widget-get-root-window (self `<gtk-widget>') => 
          (ret `<gdk-window>')
 -- Method: get-root-window
     Get the root window where this widget is located. This function
     can only be called after the widget has been added to a widget
     heirarchy with `<gtk-window>' at the top.

     The root window is useful for such purposes as creating a popup
     `<gdk-window>' associated with the window. In general, you should
     only create display specific resources when a widget has been
     realized, and you should free those resources when the widget is
     unrealized.

    WIDGET
          a `<gtk-widget>'

    RET
          the `<gdk-window>' root window for the toplevel for this
          widget.


     Since 2.2


 -- Function: gtk-widget-get-screen (self `<gtk-widget>') => 
          (ret `<gdk-screen>')
 -- Method: get-screen
     Get the `<gdk-screen>' from the toplevel window associated with
     this widget. This function can only be called after the widget has
     been added to a widget hierarchy with a `<gtk-window>' at the top.

     In general, you should only create screen specific resources when
     a widget has been realized, and you should free those resources
     when the widget is unrealized.

    WIDGET
          a `<gtk-widget>'

    RET
          the `<gdk-screen>' for the toplevel for this widget.


     Since 2.2


 -- Function: gtk-widget-has-screen (self `<gtk-widget>') => 
          (ret `bool')
 -- Method: has-screen
     Checks whether there is a `<gdk-screen>' is associated with this
     widget.  All toplevel widgets have an associated screen, and all
     widgets added into a heirarchy with a toplevel window at the top.

    WIDGET
          a `<gtk-widget>'

    RET
          ``#t'' if there is a `<gdk-screen>' associcated with the
          widget.


     Since 2.2


 -- Function: gtk-widget-get-size-request (self `<gtk-widget>') => 
          (width `int') (height `int')
 -- Method: get-size-request
     Gets the size request that was explicitly set for the widget using
     `gtk-widget-set-size-request'. A value of -1 stored in WIDTH or
     HEIGHT indicates that that dimension has not been set explicitly
     and the natural requisition of the widget will be used intead. See
     `gtk-widget-set-size-request'. To get the size a widget will
     actually use, call `gtk-widget-size-request' instead of this
     function.

    WIDGET
          a `<gtk-widget>'

    WIDTH
          return location for width, or ``#f''

    HEIGHT
          return location for height, or ``#f''



 -- Function: gtk-widget-set-child-visible (self `<gtk-widget>')
          (is_visible `bool')
 -- Method: set-child-visible
     Sets whether WIDGET should be mapped along with its when its
     parent is mapped and WIDGET has been shown with `gtk-widget-show'.

     The child visibility can be set for widget before it is added to a
     container with `gtk-widget-set-parent', to avoid mapping children
     unnecessary before immediately unmapping them. However it will be
     reset to its default state of ``#t'' when the widget is removed
     from a container.

     Note that changing the child visibility of a widget does not queue
     a resize on the widget. Most of the time, the size of a widget is
     computed from all visible children, whether or not they are
     mapped. If this is not the case, the container can queue a resize
     itself.

     This function is only useful for container implementations and
     never should be called by an application.

    WIDGET
          a `<gtk-widget>'

    IS-VISIBLE
          if ``#t'', WIDGET should be mapped along with its parent.



 -- Function: gtk-widget-set-size-request (self `<gtk-widget>')
          (width `int') (height `int')
 -- Method: set-size-request
     Sets the minimum size of a widget; that is, the widget's size
     request will be WIDTH by HEIGHT. You can use this function to
     force a widget to be either larger or smaller than it normally
     would be.

     In most cases, `gtk-window-set-default-size' is a better choice for
     toplevel windows than this function; setting the default size will
     still allow users to shrink the window. Setting the size request
     will force them to leave the window at least as large as the size
     request. When dealing with window sizes,
     `gtk-window-set-geometry-hints' can be a useful function as well.

     Note the inherent danger of setting any fixed size - themes,
     translations into other languages, different fonts, and user
     action can all change the appropriate size for a given widget. So,
     it's basically impossible to hardcode a size that will always be
     correct.

     The size request of a widget is the smallest size a widget can
     accept while still functioning well and drawing itself correctly.
     However in some strange cases a widget may be allocated less than
     its requested size, and in many cases a widget may be allocated
     more space than it requested.

     If the size request in a given direction is -1 (unset), then the
     "natural" size request of the widget will be used instead.

     Widgets can't actually be allocated a size less than 1 by 1, but
     you can pass 0,0 to this function to mean "as small as possible."

    WIDGET
          a `<gtk-widget>'

    WIDTH
          width WIDGET should request, or -1 to unset

    HEIGHT
          height WIDGET should request, or -1 to unset



 -- Function: gtk-widget-thaw-child-notify (self `<gtk-widget>')
 -- Method: thaw-child-notify
     Reverts the effect of a previous call to
     `gtk-widget-freeze-child-notify'.  This causes all queued
     "child-notify" signals on WIDGET to be emitted.

    WIDGET
          a `<gtk-widget>'



 -- Function: gtk-widget-set-no-show-all (self `<gtk-widget>')
          (no_show_all `bool')
 -- Method: set-no-show-all
     Sets the "no_show_all" property, which determines whether calls to
     `gtk-widget-show-all' and `gtk-widget-hide-all' will affect this
     widget.

     This is mostly for use in constructing widget hierarchies with
     externally controlled visibility, see `<gtk-ui-manager>'.

    WIDGET
          a `<gtk-widget>'

    NO-SHOW-ALL
          the new value for the "no_show_all" property


     Since 2.4


 -- Function: gtk-widget-get-no-show-all (self `<gtk-widget>') => 
          (ret `bool')
 -- Method: get-no-show-all
     Returns the current value of the "no_show_all" property, which
     determines whether calls to `gtk-widget-show-all' and
     `gtk-widget-hide-all' will affect this widget.

    WIDGET
          a `<gtk-widget>'

    RET
          the current value of the "no_show_all" property.


     Since 2.4


 -- Function: gtk-widget-list-mnemonic-labels (self `<gtk-widget>') => 
          (ret `glist-of')
 -- Method: list-mnemonic-labels
     Returns a newly allocated list of the widgets, normally labels,
     for which this widget is a the target of a mnemonic (see for
     example, `gtk-label-set-mnemonic-widget').

     The widgets in the list are not individually referenced. If you
     want to iterate through the list and perform actions involving
     callbacks that might destroy the widgets, you _must_ call
     `g_list_foreach (result, (GFunc)g_object_ref, NULL)' first, and
     then unref all the widgets afterwards.

    WIDGET
          a `<gtk-widget>'

    RET
          the list of mnemonic labels; free this list with
          `g-list-free' when you are done with it.


     Since 2.4


 -- Function: gtk-widget-add-mnemonic-label (self `<gtk-widget>')
          (label `<gtk-widget>')
 -- Method: add-mnemonic-label
     Adds a widget to the list of mnemonic labels for this widget. (See
     `gtk-widget-list-mnemonic-labels'). Note the list of mnemonic
     labels for the widget is cleared when the widget is destroyed, so
     the caller must make sure to update its internal state at this
     point as well, by using a connection to the ::destroy signal or a
     weak notifier.

    WIDGET
          a `<gtk-widget>'

    LABEL
          a `<gtk-widget>' that acts as a mnemonic label for WIDGET.


     Since 2.4


 -- Function: gtk-widget-remove-mnemonic-label (self `<gtk-widget>')
          (label `<gtk-widget>')
 -- Method: remove-mnemonic-label
     Removes a widget from the list of mnemonic labels for this widget.
     (See `gtk-widget-list-mnemonic-labels'). The widget must have
     previously been added to the list with
     `gtk-widget-add-mnemonic-label'.

    WIDGET
          a `<gtk-widget>'

    LABEL
          a `<gtk-widget>' that was previously set as a mnemnic label
          for WIDGET with `gtk-widget-add-mnemonic-label'.


     Since 2.4


 -- Function: gtk-widget-get-action (self `<gtk-widget>') => 
          (ret `<gtk-action>')
 -- Method: get-action
     Returns the `<gtk-action>' that WIDGET is a proxy for. See also
     `gtk-action-get-proxies'.

    WIDGET
          a `<gtk-widget>'

    RET
          the action that a widget is a proxy for, or ``#f'', if it is
          not attached to an action.


     Since 2.10


 -- Function: gtk-widget-is-composited (self `<gtk-widget>') => 
          (ret `bool')
 -- Method: is-composited
     Whether WIDGET can rely on having its alpha channel drawn
     correctly. On X11 this function returns whether a compositing
     manager is running for WIDGET's screen

    WIDGET
          a `<gtk-widget>'

    RET
          ``#t'' if the widget can rely on its alpha channel being drawn
          correctly.


     Since 2.10


 -- Function: gtk-requisition-copy (self `<gtk-requisition>') => 
          (ret `<gtk-requisition>')
     Copies a `<gtk-requisition>'.

    REQUISITION
          a `<gtk-requisition>'.

    RET
          a copy of REQUISITION.




File: guile-gnome-gtk.info,  Node: GtkIMContext,  Next: GtkPlug,  Prev: GtkWidget,  Up: Top

143 GtkIMContext
****************

Base class for input method contexts

143.1 Overview
==============

143.2 Usage
===========

 -- Class: <gtk-im-context>
     Derives from `<gobject>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Signal on <gtk-im-context>: preedit-start

 -- Signal on <gtk-im-context>: preedit-end

 -- Signal on <gtk-im-context>: preedit-changed

 -- Signal on <gtk-im-context>: commit (arg0 `<gchararray>')

 -- Signal on <gtk-im-context>: retrieve-surrounding => `<gboolean>'

 -- Signal on <gtk-im-context>: delete-surrounding (arg0 `<gint>')
          (arg1 `<gint>') => `<gboolean>'

 -- Function: gtk-im-context-set-client-window
          (self `<gtk-im-context>') (window `<gdk-window>')
 -- Method: set-client-window
     Set the client window for the input context; this is the
     `<gdk-window>' in which the input appears. This window is used in
     order to correctly position status windows, and may also be used
     for purposes internal to the input method.

    CONTEXT
          a `<gtk-im-context>'

    WINDOW
          the client window. This may be ``#f'' to indicate that the
          previous client window no longer exists.



 -- Function: gtk-im-context-filter-keypress (self `<gtk-im-context>')
          (event `<gdk-event-key>') =>  (ret `bool')
 -- Method: filter-keypress
     Allow an input method to internally handle key press and release
     events. If this function returns ``#t'', then no further
     processing should be done for this key event.

    CONTEXT
          a `<gtk-im-context>'

    EVENT
          the key event

    RET
          ``#t'' if the input method handled the key event.



 -- Function: gtk-im-context-focus-in (self `<gtk-im-context>')
 -- Method: focus-in
     Notify the input method that the widget to which this input
     context corresponds has gained focus. The input method may, for
     example, change the displayed feedback to reflect this change.

    CONTEXT
          a `<gtk-im-context>'



 -- Function: gtk-im-context-focus-out (self `<gtk-im-context>')
 -- Method: focus-out
     Notify the input method that the widget to which this input
     context corresponds has lost focus. The input method may, for
     example, change the displayed feedback or reset the contexts state
     to reflect this change.

    CONTEXT
          a `<gtk-im-context>'



 -- Function: gtk-im-context-reset (self `<gtk-im-context>')
 -- Method: reset
     Notify the input method that a change such as a change in cursor
     position has been made. This will typically cause the input method
     to clear the preedit state.

    CONTEXT
          a `<gtk-im-context>'



 -- Function: gtk-im-context-set-cursor-location
          (self `<gtk-im-context>') (area `<gdk-rectangle>')
 -- Method: set-cursor-location
     Notify the input method that a change in cursor position has been
     made. The location is relative to the client window.

    CONTEXT
          a `<gtk-im-context>'

    AREA
          new location



 -- Function: gtk-im-context-set-use-preedit (self `<gtk-im-context>')
          (use_preedit `bool')
 -- Method: set-use-preedit
     Sets whether the IM context should use the preedit string to
     display feedback.  If USE-PREEDIT is FALSE (default is TRUE), then
     the IM context may use some other method to display feedback, such
     as displaying it in a child of the root window.

    CONTEXT
          a `<gtk-im-context>'

    USE-PREEDIT
          whether the IM context should use the preedit string.



 -- Function: gtk-im-context-set-surrounding (self `<gtk-im-context>')
          (text `mchars') (len `int') (cursor_index `int')
 -- Method: set-surrounding
     Sets surrounding context around the insertion point and preedit
     string. This function is expected to be called in response to the
     GtkIMContext::retrieve_surrounding signal, and will likely have no
     effect if called at other times.

    CONTEXT
          a `<gtk-im-context>'

    TEXT
          text surrounding the insertion point, as UTF-8. the preedit
          string should not be included within TEXT.

    LEN
          the length of TEXT, or -1 if TEXT is nul-terminated

    CURSOR-INDEX
          the byte index of the insertion cursor within TEXT.



 -- Function: gtk-im-context-get-surrounding (self `<gtk-im-context>')
          =>  (ret `bool') (text `mchars') (cursor_index `int')
 -- Method: get-surrounding
     Retrieves context around the insertion point. Input methods
     typically want context in order to constrain input text based on
     existing text; this is important for languages such as Thai where
     only some sequences of characters are allowed.

     This function is implemented by emitting the
     GtkIMContext::retrieve_surrounding signal on the input method; in
     response to this signal, a widget should provide as much context
     as is available, up to an entire paragraph, by calling
     `gtk-im-context-set-surrounding'. Note that there is no obligation
     for a widget to respond to the ::retrieve_surrounding signal, so
     input methods must be prepared to function without context.

    CONTEXT
          a `<gtk-im-context>'

    TEXT
          location to store a UTF-8 encoded string of text holding
          context around the insertion point. If the function returns
          ``#t'', then you must free the result stored in this location
          with `g-free'.

    CURSOR-INDEX
          location to store byte index of the insertion cursor within
          TEXT.

    RET
          ``#t'' if surrounding text was provided; in this case you
          must free the result stored in *text.



 -- Function: gtk-im-context-delete-surrounding
          (self `<gtk-im-context>') (offset `int') (n_chars `int') => 
          (ret `bool')
 -- Method: delete-surrounding
     Asks the widget that the input context is attached to to delete
     characters around the cursor position by emitting the
     GtkIMContext::delete_surrounding signal. Note that OFFSET and
     N-CHARS are in characters not in bytes which differs from the
     usage other places in `<gtk-im-context>'.

     In order to use this function, you should first call
     `gtk-im-context-get-surrounding' to get the current context, and
     call this function immediately afterwards to make sure that you
     know what you are deleting. You should also account for the fact
     that even if the signal was handled, the input context might not
     have deleted all the characters that were requested to be deleted.

     This function is used by an input method that wants to make
     subsitutions in the existing text in response to new input. It is
     not useful for applications.

    CONTEXT
          a `<gtk-im-context>'

    OFFSET
          offset from cursor position in chars; a negative value means
          start before the cursor.

    N-CHARS
          number of characters to delete.

    RET
          ``#t'' if the signal was handled.




File: guile-gnome-gtk.info,  Node: GtkPlug,  Next: GtkSocket,  Prev: GtkIMContext,  Up: Top

144 GtkPlug
***********

Toplevel for embedding into other processes

144.1 Overview
==============

Together with `<gtk-socket>', `<gtk-plug>' provides the ability to
embed widgets from one process into another process in a fashion that is
transparent to the user. One process creates a `<gtk-socket>' widget
and, passes the ID of that widgets window to the other process, which
then creates a `<gtk-plug>' with that window ID. Any widgets contained
in the `<gtk-plug>' then will appear inside the first applications
window.

   The `<gtk-plug>' and `<gtk-socket>' widgets are currently not
available on all platforms supported by GTK+.

144.2 Usage
===========

 -- Class: <gtk-plug>
     Derives from `<gtk-window>'.

     This class defines the following properties:

    `embedded'
          Whether or not the plug is embedded



 -- Signal on <gtk-plug>: embedded

 -- Function: gtk-plug-construct (self `<gtk-plug>')
          (socket_id `unsigned-long')
 -- Method: construct
     Finish the initialization of PLUG for a given `<gtk-socket>'
     identified by SOCKET-ID. This function will generally only be used
     by classes deriving from `<gtk-plug>'.

    PLUG
          a `<gtk-plug>'.

    SOCKET-ID
          the XID of the socket's window.



 -- Function: gtk-plug-construct-for-display (self `<gtk-plug>')
          (display `<gdk-display>') (socket_id `unsigned-long')
 -- Method: construct-for-display
     Finish the initialization of PLUG for a given `<gtk-socket>'
     identified by SOCKET-ID which is currently displayed on DISPLAY.
     This function will generally only be used by classes deriving from
     `<gtk-plug>'.

    PLUG
          a `<gtk-plug>'.

    DISPLAY
          the `<gdk-display>' associated with SOCKET-ID's
          `<gtk-socket>'.

    SOCKET-ID
          the XID of the socket's window.


     Since 2.2


 -- Function: gtk-plug-new (socket_id `unsigned-long') => 
          (ret `<gtk-widget>')
     Creates a new plug widget inside the `<gtk-socket>' identified by
     SOCKET-ID. If SOCKET-ID is 0, the plug is left "unplugged" and can
     later be plugged into a `<gtk-socket>' by `gtk-socket-add-id'.

    SOCKET-ID
          the window ID of the socket, or 0.

    RET
          the new `<gtk-plug>' widget.



 -- Function: gtk-plug-new-for-display (display `<gdk-display>')
          (socket_id `unsigned-long') =>  (ret `<gtk-widget>')
     Create a new plug widget inside the `<gtk-socket>' identified by
     socket_id.

    DISPLAY
          the `<gdk-display>' on which SOCKET-ID is displayed

    SOCKET-ID
          the XID of the socket's window.

    RET
          the new `<gtk-plug>' widget.


     Since 2.2


 -- Function: gtk-plug-get-id (self `<gtk-plug>') => 
          (ret `unsigned-long')
 -- Method: get-id
     Gets the window ID of a `<gtk-plug>' widget, which can then be
     used to embed this window inside another window, for instance with
     `gtk-socket-add-id'.

    PLUG
          a `<gtk-plug>'.

    RET
          the window ID for the plug




File: guile-gnome-gtk.info,  Node: GtkSocket,  Next: GtkCurve,  Prev: GtkPlug,  Up: Top

145 GtkSocket
*************

Container for widgets from other processes

145.1 Overview
==============

Together with `<gtk-plug>', `<gtk-socket>' provides the ability to
embed widgets from one process into another process in a fashion that is
transparent to the user. One process creates a `<gtk-socket>' widget
and, passes the that widget's window ID to the other process, which
then creates a `<gtk-plug>' with that window ID. Any widgets contained
in the `<gtk-plug>' then will appear inside the first applications
window.

   The socket's window ID is obtained by using `gtk-socket-get-id'.
Before using this function, the socket must have been realized, and for
hence, have been added to its parent.


     GtkWidget *socket = gtk_socket_new ();
     gtk_widget_show (socket);
     gtk_container_add (GTK_CONTAINER (parent), socket);

     /* The following call is only necessary if one of
      * the ancestors of the socket is not yet visible.
      */
     gtk_widget_realize (socket);
     g_print ("The ID of the sockets window is %x\n",
              gtk_socket_get_id (socket));

   Note that if you pass the window ID of the socket to another process
that will create a plug in the socket, you must make sure that the
socket widget is not destroyed until that plug is created. Violating
this rule will cause unpredictable consequences, the most likely
consequence being that the plug will appear as a separate toplevel
window. You can check if the plug has been created by examining the
field of the `<gtk-socket>' structure. If this field is non-``#f'',
then the plug has been successfully created inside of the socket.

   When GTK+ is notified that the embedded window has been destroyed,
then it will destroy the socket as well. You should always, therefore,
be prepared for your sockets to be destroyed at any time when the main
event loop is running.

   The communication between a `<gtk-socket>' and a `<gtk-plug>' follows
the XEmbed (http://www.freedesktop.org/standards/xembed-spec) protocol.
This protocol has also been implemented in other toolkits, e.g. ,
allowing the same level of integration when embedding a widget in GTK
or vice versa.

   A socket can also be used to swallow arbitrary pre-existing
top-level windows using `gtk-socket-steal', though the integration when
this is done will not be as close as between a `<gtk-plug>' and a
`<gtk-socket>'.

   The `<gtk-plug>' and `<gtk-socket>' widgets are currently not
available on all platforms supported by GTK+.

145.2 Usage
===========

 -- Class: <gtk-socket>
     Derives from `<gtk-container>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Signal on <gtk-socket>: plug-added
     This signal is emitted when a client is successfully added to the
     socket.


 -- Signal on <gtk-socket>: plug-removed => `<gboolean>'
     This signal is emitted when a client is removed from the socket.
     The default action is to destroy the `<gtk-socket>' widget, so if
     you want to reuse it you must add a signal handler that returns
     ``#t''.


 -- Function: gtk-socket-new =>  (ret `<gtk-widget>')
     Create a new empty `<gtk-socket>'.

    RET
          the new `<gtk-socket>'.



 -- Function: gtk-socket-add-id (self `<gtk-socket>')
          (window_id `unsigned-long')
 -- Method: add-id
     Adds an XEMBED client, such as a `<gtk-plug>', to the
     `<gtk-socket>'.  The client may be in the same process or in a
     different process.

     To embed a `<gtk-plug>' in a `<gtk-socket>', you can either create
     the `<gtk-plug>' with `gtk_plug_new (0)', call `gtk-plug-get-id' to
     get the window ID of the plug, and then pass that to the
     `gtk-socket-add-id', or you can call `gtk-socket-get-id' to get the
     window ID for the socket, and call `gtk-plug-new' passing in that
     ID.

     The `<gtk-socket>' must have already be added into a toplevel
     window before you can make this call.

    SOCKET
          a `<gtk-socket>'

    WINDOW-ID
          the window ID of a client participating in the XEMBED
          protocol.



 -- Function: gtk-socket-get-id (self `<gtk-socket>') => 
          (ret `unsigned-long')
 -- Method: get-id
     Gets the window ID of a `<gtk-socket>' widget, which can then be
     used to create a client embedded inside the socket, for instance
     with `gtk-plug-new'.

     The `<gtk-socket>' must have already be added into a toplevel
     window before you can make this call.

    SOCKET
          a `<gtk-socket>'.

    RET
          the window ID for the socket




File: guile-gnome-gtk.info,  Node: GtkCurve,  Next: GtkGammaCurve,  Prev: GtkSocket,  Up: Top

146 GtkCurve
************

Allows direct editing of a curve

146.1 Overview
==============

This widget is considered too specialized/little-used for GTK+, and
will in the future be moved to some other package. If your application
needs this widget, feel free to use it, as the widget does work and is
useful in some applications; it's just not of general interest.
However, we are not accepting new features for the widget, and it will
eventually move out of the GTK+ distribution.

   The `<gtk-curve>' widget allows the user to edit a curve covering a
range of values. It is typically used to fine-tune color balances in
graphics applications like the Gimp.

   The `<gtk-curve>' widget has 3 modes of operation - spline, linear
and free. In spline mode the user places points on the curve which are
automatically connected together into a smooth curve. In linear mode
the user places points on the curve which are connected by straight
lines. In free mode the user can draw the points of the curve freely,
and they are not connected at all.

146.2 Usage
===========

 -- Class: <gtk-curve>
     Derives from `<gtk-drawing-area>'.

     This class defines the following properties:

    `curve-type'
          Is this curve linear, spline interpolated, or free-form

    `min-x'
          Minimum possible value for X

    `max-x'
          Maximum possible X value

    `min-y'
          Minimum possible value for Y

    `max-y'
          Maximum possible value for Y



 -- Signal on <gtk-curve>: curve-type-changed
     Emitted when the curve type has been changed. The curve type can
     be changed explicitly with a call to `gtk-curve-set-curve-type'.
     It is also changed as a side-effect of calling `gtk-curve-reset'
     or `gtk-curve-set-gamma'.


 -- Function: gtk-curve-new =>  (ret `<gtk-widget>')
     Creates a new `<gtk-curve>'.

    RET
          a new `<gtk-curve>'.



 -- Function: gtk-curve-reset (self `<gtk-curve>')
 -- Method: reset
     Resets the curve to a straight line from the minimum x and y
     values to the maximum x and y values (i.e. from the bottom-left to
     the top-right corners). The curve type is not changed.

    CURVE
          a `<gtk-curve>'.



 -- Function: gtk-curve-set-gamma (self `<gtk-curve>') (gamma `float')
 -- Method: set-gamma
     Recomputes the entire curve using the given gamma value. A gamma
     value of 1 results in a straight line. Values greater than 1
     result in a curve above the straight line. Values less than 1
     result in a curve below the straight line. The curve type is
     changed to `GTK_CURVE_TYPE_FREE'. FIXME: Needs a more precise
     definition of gamma.

    CURVE
          a `<gtk-curve>'.

    GAMMA
          the gamma value.



 -- Function: gtk-curve-set-range (self `<gtk-curve>') (min_x `float')
          (max_x `float') (min_y `float') (max_y `float')
 -- Method: set-range
     Sets the minimum and maximum x and y values of the curve. The
     curve is also reset with a call to `gtk-curve-reset'.

    CURVE
          a `<gtk-curve>'.

    MIN-X
          the minimum x value.

    MAX-X
          the maximum x value.

    MIN-Y
          the minimum y value.

    MAX-Y
          the maximum y value.




File: guile-gnome-gtk.info,  Node: GtkGammaCurve,  Next: GtkRuler,  Prev: GtkCurve,  Up: Top

147 GtkGammaCurve
*****************

a subclass of for editing gamma curves.

147.1 Overview
==============

This widget is considered too specialized/little-used for GTK+, and
will in the future be moved to some other package. If your application
needs this widget, feel free to use it, as the widget does work and is
useful in some applications; it's just not of general interest.
However, we are not accepting new features for the widget, and it will
eventually move out of the GTK+ distribution.

   The `<gtk-gamma-curve>' widget is a variant of `<gtk-curve>'
specifically for editing gamma curves, which are used in graphics
applications such as the Gimp.

   The `<gtk-gamma-curve>' widget shows a curve which the user can edit
with the mouse just like a `<gtk-curve>' widget. On the right of the
curve it also displays 5 buttons, 3 of which change between the 3 curve
modes (spline, linear and free), and the other 2 set the curve to a
particular gamma value, or reset it to a straight line.

147.2 Usage
===========

 -- Class: <gtk-gamma-curve>
     Derives from `<gtk-vbox>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-gamma-curve-new =>  (ret `<gtk-widget>')
     Creates a new `<gtk-gamma-curve>'.

    RET
          a new `<gtk-gamma-curve>'.




File: guile-gnome-gtk.info,  Node: GtkRuler,  Next: GtkHRuler,  Prev: GtkGammaCurve,  Up: Top

148 GtkRuler
************

Base class for horizontal or vertical rulers

148.1 Overview
==============

This widget is considered too specialized/little-used for GTK+, and
will in the future be moved to some other package. If your application
needs this widget, feel free to use it, as the widget does work and is
useful in some applications; it's just not of general interest.
However, we are not accepting new features for the widget, and it will
eventually move out of the GTK+ distribution.

   The GTKRuler widget is a base class for horizontal and vertical
rulers. Rulers are used to show the mouse pointer's location in a
window. The ruler can either be horizontal or vertical on the window.
Within the ruler a small triangle indicates the location of the mouse
relative to the horizontal or vertical ruler. See `<gtk-hruler>' to
learn how to create a new horizontal ruler.  See `<gtk-vruler>' to
learn how to create a new vertical ruler.

148.2 Usage
===========

 -- Class: <gtk-ruler>
     Derives from `<gtk-widget>'.

     This class defines the following properties:

    `lower'
          Lower limit of ruler

    `upper'
          Upper limit of ruler

    `position'
          Position of mark on the ruler

    `max-size'
          Maximum size of the ruler

    `metric'
          The metric used for the ruler



 -- Function: gtk-ruler-set-metric (self `<gtk-ruler>')
          (metric `<gtk-metric-type>')
 -- Method: set-metric
     This calls the `<gtk-metric-type>' to set the ruler to units
     defined.  Available units are GTK_PIXELS, GTK_INCHES, or
     GTK_CENTIMETERS. The default unit of measurement is GTK_PIXELS.

    RULER
          the gtkruler

    METRIC
          the unit of measurement



 -- Function: gtk-ruler-set-range (self `<gtk-ruler>') (lower `double')
          (upper `double') (position `double') (max_size `double')
 -- Method: set-range
     This sets the range of the ruler using gfloat lower, gfloat upper,
     gfloat position, and gfloat max_size.

    RULER
          the gtkruler

    LOWER
          the lower limit of the ruler

    UPPER
          the upper limit of the ruler

    POSITION
          the mark on the ruler

    MAX-SIZE
          the maximum size of the ruler



 -- Function: gtk-ruler-get-metric (self `<gtk-ruler>') => 
          (ret `<gtk-metric-type>')
 -- Method: get-metric
     Gets the units used for a `<gtk-ruler>'. See
     `gtk-ruler-set-metric'.

    RULER
          a `<gtk-ruler>'

    RET
          the units currently used for RULER



 -- Function: gtk-ruler-get-range (self `<gtk-ruler>') => 
          (lower `double') (upper `double') (position `double')
          (max_size `double')
 -- Method: get-range
     Retrieves values indicating the range and current position of a
     `<gtk-ruler>'. See `gtk-ruler-set-range'.

    RULER
          a `<gtk-ruler>'

    LOWER
          location to store lower limit of the ruler, or ``#f''

    UPPER
          location to store upper limit of the ruler, or ``#f''

    POSITION
          location to store the current position of the mark on the
          ruler, or ``#f''

    MAX-SIZE
          location to store the maximum size of the ruler used when
          calculating the space to leave for the text, or ``#f''.




File: guile-gnome-gtk.info,  Node: GtkHRuler,  Next: GtkVRuler,  Prev: GtkRuler,  Up: Top

149 GtkHRuler
*************

A horizontal ruler.

149.1 Overview
==============

This widget is considered too specialized/little-used for GTK+, and
will in the future be moved to some other package. If your application
needs this widget, feel free to use it, as the widget does work and is
useful in some applications; it's just not of general interest.
However, we are not accepting new features for the widget, and it will
eventually move out of the GTK+ distribution.

   The HRuler widget is a widget arranged horizontally creating a ruler
that is utilized around other widgets such as a text widget. The ruler
is used to show the location of the mouse on the window and to show the
size of the window in specified units. The available units of
measurement are GTK_PIXELS, GTK_INCHES and GTK_CENTIMETERS. GTK_PIXELS
is the default. rulers.

149.2 Usage
===========

 -- Class: <gtk-hruler>
     Derives from `<gtk-ruler>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-hruler-new =>  (ret `<gtk-widget>')
     Creates a new horizontal ruler.

    RET
          a new `<gtk-hruler>'.




File: guile-gnome-gtk.info,  Node: GtkVRuler,  Next: GtkRecentManager,  Prev: GtkHRuler,  Up: Top

150 GtkVRuler
*************

A vertical ruler.

150.1 Overview
==============

This widget is considered too specialized/little-used for GTK+, and
will in the future be moved to some other package. If your application
needs this widget, feel free to use it, as the widget does work and is
useful in some applications; it's just not of general interest.
However, we are not accepting new features for the widget, and it will
eventually move out of the GTK+ distribution.

   The VRuler widget is a widget arranged vertically creating a ruler
that is utilized around other widgets such as a text widget. The ruler
is used to show the location of the mouse on the window and to show the
size of the window in specified units. The available units of
measurement are GTK_PIXELS, GTK_INCHES and GTK_CENTIMETERS. GTK_PIXELS
is the default. rulers.

150.2 Usage
===========

 -- Class: <gtk-vruler>
     Derives from `<gtk-ruler>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-vruler-new =>  (ret `<gtk-widget>')
     Creates a new vertical ruler

    RET
          a new `<gtk-vruler>'.




File: guile-gnome-gtk.info,  Node: GtkRecentManager,  Next: GtkRecentChooser,  Prev: GtkVRuler,  Up: Top

151 GtkRecentManager
********************

Managing Recently Used Files

151.1 Overview
==============

`<gtk-recent-manager>' provides a facility for adding, removing and
looking up recently used files. Each recently used file is identified
by its URI, and has meta-data associated to it, like the names and
command lines of the applications that have registered it, the number
of time each application has registered the same file, the mime type of
the file and whether the file should be displayed only by the
applications that have registered it.

   The `<gtk-recent-manager>' acts like a database of all the recently
used files. You can create new `<gtk-recent-manager>' objects, but it
is more efficient to use the standard recent manager for the
`<gdk-screen>' so that informations about the recently used files is
shared with other people using them. In case the default screen is
being used, adding a new recently used file is as simple as:


     GtkRecentManager *manager;

     manager = gtk_recent_manager_get_default ();
     gtk_recent_manager_add_item (manager, file_uri);


     GtkRecentManager *manager;
     GtkRecentInfo *info;
     GError *error = NULL;

     manager = gtk_recent_manager_get_default ();
     info = gtk_recent_manager_lookup_item (manager, file_uri, &error);
     if (error)
       {
         g_warning ("Could not find the file: %s", error->message);
         g_error_free (error);
       }
     else
       {
         /* Use the info object */
         gtk_recent_info_unref (info);
       }

   Recently used files are supported since GTK+ 2.10.

151.2 Usage
===========

 -- Class: <gtk-recent-manager>
     Derives from `<gobject>'.

     This class defines the following properties:

    `filename'
          The full path to the file to be used to store and read the
          list

    `limit'
          The maximum number of items to be returned by
          gtk_recent_manager_get_items()

    `size'
          The size of the recently used resources list



 -- Signal on <gtk-recent-manager>: changed
     Emitted when the current recently used resources manager changes
     its contents.

     Since 2.10


 -- Class: <gtk-recent-info>
     Derives from `<gboxed>'.


 -- Function: gtk-recent-manager-new =>  (ret `<gtk-recent-manager>')
     Creates a new recent manager object. Recent manager objects are
     used to handle the list of recently used resources. A
     `<gtk-recent-manager>' object monitors the recently used resources
     list, and emits the "changed" signal each time something inside
     the list changes.

     `<gtk-recent-manager>' objects are expensive: be sure to create
     them only when needed. You should use the
     `gtk-recent-manager-new-for-screen' or the
     `gtk-recent-manager-get-default' functions instead.

    RET
          A newly created `<gtk-recent-manager>' object.


     Since 2.10


 -- Function: gtk-recent-manager-get-default => 
          (ret `<gtk-recent-manager>')
     Gets the recent manager for the default screen. See
     `gtk-recent-manager-get-for-screen'.

    RET
          A unique `<gtk-recent-manager>' associated with the default
          screen. This recent manager is associated with the screen and
          can be used as long as the screen is open. Do not ref or
          unref it.


     Since 2.10


 -- Function: gtk-recent-manager-get-for-screen (screen `<gdk-screen>')
          =>  (ret `<gtk-recent-manager>')
     Gets the recent manager object associated with SCREEN; if this
     function has not previously been called for the given screen, a
     new recent manager object will be created and associated with the
     screen. Recent manager objects are fairly expensive to create, so
     using this function is usually a better choice than calling
     `gtk-recent-manager-new' and setting the screen yourself; by using
     this function a single recent manager object will be shared
     between users.

    SCREEN
          a `<gdk-screen>'

    RET
          A unique `<gtk-recent-manager>' associated with the given
          screen. This recent manager is associated to the with the
          screen and can be used as long as the screen is open. Do not
          ref or unref it.


     Since 2.10


 -- Function: gtk-recent-manager-set-screen
          (self `<gtk-recent-manager>') (screen `<gdk-screen>')
 -- Method: set-screen
     Sets the screen for a recent manager; the screen is used to track
     the user's currently configured recently used documents storage.

    MANAGER
          a `<gtk-recent-manager>'

    SCREEN
          a `<gdk-screen>'


     Since 2.10


 -- Function: gtk-recent-manager-add-item (self `<gtk-recent-manager>')
          (uri `mchars') =>  (ret `bool')
 -- Method: add-item
     Adds a new resource, pointed by URI, into the recently used
     resources list.

     This function automatically retrieving some of the needed metadata
     and setting other metadata to common default values; it then feeds
     the data to `gtk-recent-manager-add-full'.

     See `gtk-recent-manager-add-full' if you want to explicitely
     define the metadata for the resource pointed by URI.

    MANAGER
          a `<gtk-recent-manager>'

    URI
          a valid URI

    RET
          ``#t'' if the new item was successfully added to the recently
          used resources list


     Since 2.10


 -- Function: gtk-recent-manager-remove-item
          (self `<gtk-recent-manager>') (uri `mchars') =>  (ret `bool')
 -- Method: remove-item
     Removes a resource pointed by URI from the recently used resources
     list handled by a recent manager.

    MANAGER
          a `<gtk-recent-manager>'

    URI
          the URI of the item you wish to remove

    ERROR
          return location for a `<g-error>', or ``#f''

    RET
          ``#t'' if the item pointed by URI has been successfully
          removed by the recently used resources list, and ``#f''
          otherwise.


     Since 2.10


 -- Function: gtk-recent-manager-lookup-item
          (self `<gtk-recent-manager>') (uri `mchars') => 
          (ret `<gtk-recent-info>')
 -- Method: lookup-item
     Searches for a URI inside the recently used resources list, and
     returns a structure containing informations about the resource
     like its MIME type, or its display name.

    MANAGER
          a `<gtk-recent-manager>'

    URI
          a URI

    ERROR
          a return location for a `<g-error>', or ``#f''

    RET
          a `<gtk-recent-info>' structure containing information about
          the resource pointed by URI, or ``#f'' if the URI was not
          registered in the recently used resources list. Free with
          `gtk-recent-info-unref'.


     Since 2.10


 -- Function: gtk-recent-manager-has-item (self `<gtk-recent-manager>')
          (uri `mchars') =>  (ret `bool')
 -- Method: has-item
     Checks whether there is a recently used resource registered with
     URI inside the recent manager.

    MANAGER
          a `<gtk-recent-manager>'

    URI
          a URI

    RET
          ``#t'' if the resource was found, ``#f'' otherwise.


     Since 2.10


 -- Function: gtk-recent-manager-move-item
          (self `<gtk-recent-manager>') (uri `mchars')
          (new_uri `mchars') =>  (ret `bool')
 -- Method: move-item
     Changes the location of a recently used resource from URI to
     NEW-URI.

     Please note that this function will not affect the resource
     pointed by the URIs, but only the URI used in the recently used
     resources list.

    MANAGER
          a `<gtk-recent-manager>'

    URI
          the URI of a recently used resource

    NEW-URI
          the new URI of the recently used resource, or ``#f'' to
          remove the item pointed by URI in the list

    ERROR
          a return location for a `<g-error>', or ``#f''

    RET
          ``#t'' on success.


     Since 2.10


 -- Function: gtk-recent-manager-get-limit
          (self `<gtk-recent-manager>') =>  (ret `int')
 -- Method: get-limit
     Gets the maximum number of items that the
     `gtk-recent-manager-get-items' function should return.

    MANAGER
          a `<gtk-recent-manager>'

    RET
          the number of items to return, or -1 for every item.


     Since 2.10


 -- Function: gtk-recent-manager-set-limit
          (self `<gtk-recent-manager>') (limit `int')
 -- Method: set-limit
     Sets the maximum number of item that the
     `gtk-recent-manager-get-items' function should return. If LIMIT is
     set to -1, then return all the items.

    MANAGER
          a `<gtk-recent-manager>'

    LIMIT
          the maximum number of items to return, or -1.


     Since 2.10


 -- Function: gtk-recent-manager-get-items
          (self `<gtk-recent-manager>') =>  (ret `glist-of')
 -- Method: get-items
     Gets the list of recently used resources.

    MANAGER
          a `<gtk-recent-manager>'

    RET
          a list of newly allocated `<gtk-recent-info>' objects. Use
          `gtk-recent-info-unref' on each item inside the list, and
          then free the list itself using `g-list-free'.


     Since 2.10


 -- Function: gtk-recent-manager-purge-items
          (self `<gtk-recent-manager>') =>  (ret `int')
 -- Method: purge-items
     Purges every item from the recently used resources list.

    MANAGER
          a `<gtk-recent-manager>'

    ERROR
          a return location for a `<g-error>', or ``#f''

    RET
          the number of items that have been removed from the recently
          used resources list.


     Since 2.10


 -- Function: gtk-recent-info-get-uri (self `<gtk-recent-info>') => 
          (ret `mchars')
     Gets the URI of the resource.

    INFO
          a `<gtk-recent-info>'

    RET
          the URI of the resource. The returned string is owned by the
          recent manager, and should not be freed.


     Since 2.10


 -- Function: gtk-recent-info-get-display-name
          (self `<gtk-recent-info>') =>  (ret `mchars')
     Gets the name of the resource. If none has been defined, the
     basename of the resource is obtained.

    INFO
          a `<gtk-recent-info>'

    RET
          the display name of the resource. The returned string is
          owned by the recent manager, and should not be freed.


     Since 2.10


 -- Function: gtk-recent-info-get-description
          (self `<gtk-recent-info>') =>  (ret `mchars')
     Gets the (short) description of the resource.

    INFO
          a `<gtk-recent-info>'

    RET
          the description of the resource. The returned string is owned
          by the recent manager, and should not be freed.


     Since 2.10


 -- Function: gtk-recent-info-get-mime-type (self `<gtk-recent-info>')
          =>  (ret `mchars')
     Gets the MIME type of the resource.

    INFO
          a `<gtk-recent-info>'

    RET
          the MIME type of the resource. The returned string is owned
          by the recent manager, and should not be freed.


     Since 2.10


 -- Function: gtk-recent-info-get-added (self `<gtk-recent-info>') => 
          (ret `long')
     Gets the timestamp (seconds from system's Epoch) when the resource
     was added to the recently used resources list.

    INFO
          a `<gtk-recent-info>'

    RET
          the number of seconds elapsed from system's Epoch when the
          resource was added to the list, or -1 on failure.


     Since 2.10


 -- Function: gtk-recent-info-get-modified (self `<gtk-recent-info>')
          =>  (ret `long')
     Gets the timestamp (seconds from system's Epoch) when the resource
     was last modified.

    INFO
          a `<gtk-recent-info>'

    RET
          the number of seconds elapsed from system's Epoch when the
          resource was last modified, or -1 on failure.


     Since 2.10


 -- Function: gtk-recent-info-get-visited (self `<gtk-recent-info>')
          =>  (ret `long')
     Gets the timestamp (seconds from system's Epoch) when the resource
     was last visited.

    INFO
          a `<gtk-recent-info>'

    RET
          the number of seconds elapsed from system's Epoch when the
          resource was last visited, or -1 on failure.


     Since 2.10


 -- Function: gtk-recent-info-get-private-hint
          (self `<gtk-recent-info>') =>  (ret `bool')
     Gets the value of the "private" flag. Resources in the recently
     used list that have this flag set to ``#t'' should only be
     displayed by the applications that have registered them.

    INFO
          a `<gtk-recent-info>'

    RET
          ``#t'' if the private flag was found, ``#f'' otherwise.


     Since 2.10


 -- Function: gtk-recent-info-last-application
          (self `<gtk-recent-info>') =>  (ret `mchars')
     Gets the name of the last application that have registered the
     recently used resource represented by INFO.

    INFO
          a `<gtk-recent-info>'

    RET
          an application name. Use `g-free' to free it.


     Since 2.10


 -- Function: gtk-recent-info-has-group (self `<gtk-recent-info>')
          (group_name `mchars') =>  (ret `bool')
     Checks whether GROUP-NAME appears inside the groups registered for
     the recently used item INFO.

    INFO
          a `<gtk-recent-info>'

    GROUP-NAME
          name of a group

    RET
          ``#t'' if the group was found.


     Since 2.10


 -- Function: gtk-recent-info-has-application
          (self `<gtk-recent-info>') (app_name `mchars') => 
          (ret `bool')
     Checks whether an application registered this resource using
     APP-NAME.

    INFO
          a `<gtk-recent-info>'

    APP-NAME
          a string containing an application name

    RET
          ``#t'' if an application with name APP-NAME was found, ``#f''
          otherwise.


     Since 2.10


 -- Function: gtk-recent-info-get-icon (self `<gtk-recent-info>')
          (size `int') =>  (ret `<gdk-pixbuf>')
     Retrieves the icon of size SIZE associated to the resource MIME
     type.

    INFO
          a `<gtk-recent-info>'

    SIZE
          the size of the icon in pixels

    RET
          a `<gdk-pixbuf>' containing the icon, or ``#f''.


     Since 2.10


 -- Function: gtk-recent-info-get-short-name (self `<gtk-recent-info>')
          =>  (ret `mchars')
     Computes a valid UTF-8 string that can be used as the name of the
     item in a menu or list. For example, calling this function on an
     item that refers to "file:///foo/bar.txt" will yield "bar.txt".

    INFO
          an `<gtk-recent-info>'

    RET
          A newly-allocated string in UTF-8 encoding; free it with
          `g-free'.


     Since 2.10


 -- Function: gtk-recent-info-get-uri-display
          (self `<gtk-recent-info>') =>  (ret `mchars')
     Gets a displayable version of the resource's URI.

    INFO
          a `<gtk-recent-info>'

    RET
          a UTF-8 string containing the resource's URI or ``#f''


     Since 2.10


 -- Function: gtk-recent-info-get-age (self `<gtk-recent-info>') => 
          (ret `int')
     Gets the number of days elapsed since the last update of the
     resource pointed by INFO.

    INFO
          a `<gtk-recent-info>'

    RET
          a positive integer containing the number of days elapsed
          since the time this resource was last modified.


     Since 2.10


 -- Function: gtk-recent-info-is-local (self `<gtk-recent-info>') => 
          (ret `bool')
     Checks whether the resource is local or not by looking at the
     scheme of its URI.

    INFO
          a `<gtk-recent-info>'

    RET
          ``#t'' if the resource is local.


     Since 2.10


 -- Function: gtk-recent-info-exists (self `<gtk-recent-info>') => 
          (ret `bool')
     Checks whether the resource pointed by INFO still exists. At the
     moment this check is done only on resources pointing to local
     files.

    INFO
          a `<gtk-recent-info>'

    RET
          ``#t'' if the resource exists


     Since 2.10


 -- Function: gtk-recent-info-match (self `<gtk-recent-info>')
          (info_b `<gtk-recent-info>') =>  (ret `bool')
     Checks whether two `<gtk-recent-info>' structures point to the same
     resource.

    INFO-A
          a `<gtk-recent-info>'

    INFO-B
          a `<gtk-recent-info>'

    RET
          ``#t'' if both `<gtk-recent-info>' structures point to se same
          resource, ``#f'' otherwise.


     Since 2.10



File: guile-gnome-gtk.info,  Node: GtkRecentChooser,  Next: GtkRecentChooserDialog,  Prev: GtkRecentManager,  Up: Top

152 GtkRecentChooser
********************

Interface implemented by GtkRecentChooserWidget, GtkRecentChooserMenu
and GtkRecentChooserDialog

152.1 Overview
==============

`<gtk-recent-chooser>' is an interface that can be implemented by
widgets displaying the list of recently used files. In GTK+, the main
objects that implement this interface are `<gtk-recent-chooser-widget>',
`<gtk-recent-chooser-dialog>' and `<gtk-recent-chooser-menu>'.

   Recently used files are supported since GTK+ 2.10.

152.2 Usage
===========

 -- Class: <gtk-recent-chooser>
     Derives from `<ginterface>'.

     This class defines the following properties:

    `sort-type'
          The sorting order of the items displayed

    `show-private'
          Whether the private items should be displayed

    `show-icons'
          Whether there should be an icon near the item

    `local-only'
          Whether the selected resource(s) should be limited to local
          file: URIs

    `select-multiple'
          Whether to allow multiple items to be selected

    `recent-manager'
          The RecentManager object to use

    `limit'
          The maximum number of items to be displayed

    `show-not-found'
          Whether the items pointing to unavailable resources should be
          displayed

    `filter'
          The current filter for selecting which resources are displayed

    `show-tips'
          Whether there should be a tooltip on the item



 -- Signal on <gtk-recent-chooser>: selection-changed
     This signal is emitted when there is a change in the set of
     selected recently used resources. This can happen when a user
     modifies the selection with the mouse or the keyboard, or when
     explicitely calling functions to change the selection.

     Since 2.10


 -- Signal on <gtk-recent-chooser>: item-activated
     This signal is emitted when the user "activates" a recent item in
     the recent chooser. This can happen by double-clicking on an item
     in the recently used resources list, or by pressing  Since 2.10


 -- Function: gtk-recent-chooser-set-show-private
          (self `<gtk-recent-chooser>') (show_private `bool')
 -- Method: set-show-private
     Whether to show recently used resources marked registered as
     private.

    CHOOSER
          a `<gtk-recent-chooser>'

    SHOW-PRIVATE
          ``#t'' to show private items, ``#f'' otherwise


     Since 2.10


 -- Function: gtk-recent-chooser-get-show-private
          (self `<gtk-recent-chooser>') =>  (ret `bool')
 -- Method: get-show-private
     Returns whether CHOOSER should display recently used resources
     registered as private.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          ``#t'' if the recent chooser should show private items,
          ``#f'' otherwise.


     Since 2.10


 -- Function: gtk-recent-chooser-set-show-icons
          (self `<gtk-recent-chooser>') (show_icons `bool')
 -- Method: set-show-icons
     Sets whether CHOOSER should show an icon near the resource when
     displaying it.

    CHOOSER
          a `<gtk-recent-chooser>'

    SHOW-ICONS
          whether to show an icon near the resource


     Since 2.10


 -- Function: gtk-recent-chooser-get-show-icons
          (self `<gtk-recent-chooser>') =>  (ret `bool')
 -- Method: get-show-icons
     Retrieves whether CHOOSER should show an icon near the resource.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          ``#t'' if the icons should be displayed, ``#f'' otherwise.


     Since 2.10


 -- Function: gtk-recent-chooser-set-local-only
          (self `<gtk-recent-chooser>') (local_only `bool')
 -- Method: set-local-only
     Sets whether only local resources, that is resources using the
     file:// URI scheme, should be shown in the recently used resources
     selector. If LOCAL-ONLY is ``#t'' (the default) then the shown
     resources are guaranteed to be accessible through the operating
     system native file system.

    CHOOSER
          a `<gtk-recent-chooser>'

    LOCAL-ONLY
          ``#t'' if only local files can be shown


     Since 2.10


 -- Function: gtk-recent-chooser-get-local-only
          (self `<gtk-recent-chooser>') =>  (ret `bool')
 -- Method: get-local-only
     Gets whether only local resources should be shown in the recently
     used resources selector. See `gtk-recent-chooser-set-local-only'

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          ``#t'' if only local resources should be shown.


     Since 2.10


 -- Function: gtk-recent-chooser-set-limit
          (self `<gtk-recent-chooser>') (limit `int')
 -- Method: set-limit
     Sets the number of items that should be returned by
     `gtk-recent-chooser-get-items' and `gtk-recent-chooser-get-uris'.

    CHOOSER
          a `<gtk-recent-chooser>'

    LIMIT
          a positive integer, or -1 for all items


     Since 2.10


 -- Function: gtk-recent-chooser-get-limit
          (self `<gtk-recent-chooser>') =>  (ret `int')
 -- Method: get-limit
     Gets the number of items returned by
     `gtk-recent-chooser-get-items' and `gtk-recent-chooser-get-uris'.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          A positive integer, or -1 meaning that all items are returned.


     Since 2.10


 -- Function: gtk-recent-chooser-set-show-tips
          (self `<gtk-recent-chooser>') (show_tips `bool')
 -- Method: set-show-tips
     Sets whether to show a tooltips on the widget.

    CHOOSER
          a `<gtk-recent-chooser>'

    SHOW-TIPS
          ``#t'' if tooltips should be shown


     Since 2.10


 -- Function: gtk-recent-chooser-get-show-tips
          (self `<gtk-recent-chooser>') =>  (ret `bool')
 -- Method: get-show-tips
     Gets whether CHOOSER should display tooltips.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          ``#t'' if the recent chooser should show tooltips, ``#f''
          otherwise.


     Since 2.10


 -- Function: gtk-recent-chooser-set-show-numbers
          (self `<gtk-recent-chooser>') (show_numbers `bool')
 -- Method: set-show-numbers
     Whether to show recently used resources prepended by a unique
     number.

     Do not use this function: use
     `gtk-recent-chooser-menu-set-show-numbers' instead.

    CHOOSER
          a `<gtk-recent-chooser>'

    SHOW-NUMBERS
          ``#t'' to show numbers, ``#f'' otherwise


     Since 2.10


 -- Function: gtk-recent-chooser-get-show-numbers
          (self `<gtk-recent-chooser>') =>  (ret `bool')
 -- Method: get-show-numbers
     Returns whether CHOOSER should display recently used resources
     prepended by a unique number.

     Do not use this function: use
     `gtk-recent-chooser-menu-get-show-numbers' instead.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          ``#t'' if the recent chooser should show display numbers,
          ``#f'' otherwise.


     Since 2.10


 -- Function: gtk-recent-chooser-set-sort-type
          (self `<gtk-recent-chooser>')
          (sort_type `<gtk-recent-sort-type>')
 -- Method: set-sort-type
     Changes the sorting order of the recently used resources list
     displayed by CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    SORT-TYPE
          sort order that the chooser should use


     Since 2.10


 -- Function: gtk-recent-chooser-get-sort-type
          (self `<gtk-recent-chooser>') => 
          (ret `<gtk-recent-sort-type>')
 -- Method: get-sort-type
     Gets the value set by `gtk-recent-chooser-set-sort-type'.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          the sorting order of the CHOOSER.


     Since 2.10


 -- Function: gtk-recent-chooser-set-current-uri
          (self `<gtk-recent-chooser>') (uri `mchars') =>  (ret `bool')
 -- Method: set-current-uri
     Sets URI as the current URI for CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    URI
          a URI

    ERROR
          return location for a `<g-error>', or ``#f''

    RET
          ``#t'' if the URI was found.


     Since 2.10


 -- Function: gtk-recent-chooser-get-current-uri
          (self `<gtk-recent-chooser>') =>  (ret `mchars')
 -- Method: get-current-uri
     Gets the URI currently selected by CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          a newly allocated string holding a URI.


     Since 2.10


 -- Function: gtk-recent-chooser-get-current-item
          (self `<gtk-recent-chooser>') =>  (ret `<gtk-recent-info>')
 -- Method: get-current-item
     Gets the `<gtk-recent-info>' currently selected by CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          a `<gtk-recent-info>'. Use `gtk-recent-info-unref' when when
          you have finished using it.


     Since 2.10


 -- Function: gtk-recent-chooser-select-uri
          (self `<gtk-recent-chooser>') (uri `mchars') =>  (ret `bool')
 -- Method: select-uri
     Selects URI inside CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    URI
          a URI

    ERROR
          return location for a `<g-error>', or ``#f''

    RET
          ``#t'' if URI was found.


     Since 2.10


 -- Function: gtk-recent-chooser-unselect-uri
          (self `<gtk-recent-chooser>') (uri `mchars')
 -- Method: unselect-uri
     Unselects URI inside CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    URI
          a URI


     Since 2.10


 -- Function: gtk-recent-chooser-select-all
          (self `<gtk-recent-chooser>')
 -- Method: select-all
     Selects all the items inside CHOOSER, if the CHOOSER supports
     multiple selection.

    CHOOSER
          a `<gtk-recent-chooser>'


     Since 2.10


 -- Function: gtk-recent-chooser-unselect-all
          (self `<gtk-recent-chooser>')
 -- Method: unselect-all
     Unselects all the items inside CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'


     Since 2.10


 -- Function: gtk-recent-chooser-get-items
          (self `<gtk-recent-chooser>') =>  (ret `glist-of')
 -- Method: get-items
     Gets the list of recently used resources in form of
     `<gtk-recent-info>' objects.

     The return value of this function is affected by the "sort-type"
     and "limit" properties of CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          A newly allocated list of `<gtk-recent-info>' objects. You
          should use `gtk-recent-info-unref' on every item of the list,
          and then free the list itself using `g-list-free'.


     Since 2.10


 -- Function: gtk-recent-chooser-add-filter
          (self `<gtk-recent-chooser>') (filter `<gtk-recent-filter>')
 -- Method: add-filter
     Adds FILTER to the list of `<gtk-recent-filter>' objects held by
     CHOOSER.

     If no previous filter objects were defined, this function will call
     `gtk-recent-chooser-set-filter'.

    CHOOSER
          a `<gtk-recent-chooser>'

    FILTER
          a `<gtk-recent-filter>'


     Since 2.10


 -- Function: gtk-recent-chooser-remove-filter
          (self `<gtk-recent-chooser>') (filter `<gtk-recent-filter>')
 -- Method: remove-filter
     Removes FILTER from the list of `<gtk-recent-filter>' objects held
     by CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    FILTER
          a `<gtk-recent-filter>'


     Since 2.10


 -- Function: gtk-recent-chooser-list-filters
          (self `<gtk-recent-chooser>') =>  (ret `gslist-of')
 -- Method: list-filters
     Gets the `<gtk-recent-filter>' objects held by CHOOSER.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          A singly linked list of `<gtk-recent-filter>' objects. You
          should just free the returned list using `g-slist-free'.


     Since 2.10


 -- Function: gtk-recent-chooser-set-filter
          (self `<gtk-recent-chooser>') (filter `<gtk-recent-filter>')
 -- Method: set-filter
     Sets FILTER as the current `<gtk-recent-filter>' object used by
     CHOOSER to affect the displayed recently used resources.

    CHOOSER
          a `<gtk-recent-chooser>'

    FILTER
          a `<gtk-recent-filter>'


     Since 2.10


 -- Function: gtk-recent-chooser-get-filter
          (self `<gtk-recent-chooser>') =>  (ret `<gtk-recent-filter>')
 -- Method: get-filter
     Gets the `<gtk-recent-filter>' object currently used by CHOOSER to
     affect the display of the recently used resources.

    CHOOSER
          a `<gtk-recent-chooser>'

    RET
          a `<gtk-recent-filter>' object.


     Since 2.10



File: guile-gnome-gtk.info,  Node: GtkRecentChooserDialog,  Next: GtkRecentChooserMenu,  Prev: GtkRecentChooser,  Up: Top

153 GtkRecentChooserDialog
**************************

Displays recently used files in a dialog

153.1 Overview
==============

`<gtk-recent-chooser-dialog>' is a dialog box suitable for displaying
the recently used documents. This widgets works by putting a
`<gtk-recent-chooser-widget>' inside a `<gtk-dialog>'. It exposes the
`<gtk-recent-chooser-iface>' interface, so you can use all the
`<gtk-recent-chooser>' functions on the recent chooser dialog as well as
those for `<gtk-dialog>'.

   Note that `<gtk-recent-chooser-dialog>' does not have any methods of
its own. Instead, you should use the functions that work on a
`<gtk-recent-chooser>'.

   In the simplest of cases, you can use the following code to use a
`<gtk-recent-chooser-dialog>' to select a recently used file:


     GtkWidget *dialog;

     dialog = gtk_recent_chooser_dialog_new ("Recent Documents",
     					parent_window,
     					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     					GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
     					NULL);

     if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
       {
         GtkRecentInfo *info;

         info = gtk_recent_chooser_get_current_item (GTK_RECENT_CHOOSER (dialog));
         open_file (gtk_recent_info_get_uri (info));
         gtk_recent_info_unref (info);
       }

     gtk_widget_destroy (dialog);

   Recently used files are supported since GTK+ 2.10.

153.2 Usage
===========

 -- Class: <gtk-recent-chooser-dialog>
     Derives from `<gtk-recent-chooser>', `<gtk-dialog>'.

     This class defines no properties, other than those defined by its
     superclasses.



File: guile-gnome-gtk.info,  Node: GtkRecentChooserMenu,  Next: GtkRecentChooserWidget,  Prev: GtkRecentChooserDialog,  Up: Top

154 GtkRecentChooserMenu
************************

Displays recently used files in a menu

154.1 Overview
==============

`<gtk-recent-chooser-menu>' is a widget suitable for displaying recently
used files inside a menu. It can be used to set a sub-menu of a
`<gtk-menu-item>' using `gtk-menu-item-set-submenu', or as the menu of
a `<gtk-menu-tool-button>'.

   Note that `<gtk-recent-chooser-menu>' does not have any methods of
its own.  Instead, you should use the functions that work on a
`<gtk-recent-chooser>'.

   Note also that `<gtk-recent-chooser-menu>' does not support multiple
filters, as it has no way to let the user choose between them as the
`<gtk-recent-chooser-widget>' and `<gtk-recent-chooser-dialog>' widgets
do. Thus using `gtk-recent-chooser-add-filter' on a
`<gtk-recent-chooser-menu>' widget will yield the same effects as using
`gtk-recent-chooser-set-filter', replacing any currently set filter with
the supplied filter; `gtk-recent-chooser-remove-filter' will remove any
currently set `<gtk-recent-filter>' object and will unset the current
filter; `gtk-recent-chooser-list-filters' will return a list containing
a single `<gtk-recent-filter>' object.

   Recently used files are supported since GTK+ 2.10.

154.2 Usage
===========

 -- Class: <gtk-recent-chooser-menu>
     Derives from `<gtk-recent-chooser>', `<gtk-menu>'.

     This class defines the following properties:

    `show-numbers'
          Whether the items should be displayed with a number



 -- Function: gtk-recent-chooser-menu-new =>  (ret `<gtk-widget>')
     Creates a new `<gtk-recent-chooser-menu>' widget.

     This kind of widget shows the list of recently used resources as a
     menu, each item as a menu item. Each item inside the menu might
     have an icon, representing its MIME type, and a number, for
     mnemonic access.

     This widget implements the `<gtk-recent-chooser>' interface.

     This widget creates its own `<gtk-recent-manager>' object. See the
     `gtk-recent-chooser-menu-new-for-manager' function to know how to
     create a `<gtk-recent-chooser-menu>' widget bound to another
     `<gtk-recent-manager>' object.

    RET
          a new `<gtk-recent-chooser-menu>'


     Since 2.10



File: guile-gnome-gtk.info,  Node: GtkRecentChooserWidget,  Next: GtkRecentFilter,  Prev: GtkRecentChooserMenu,  Up: Top

155 GtkRecentChooserWidget
**************************

Displays recently used files

155.1 Overview
==============

`<gtk-recent-chooser-widget>' is a widget suitable for selecting
recently used files. It is the main building block of a
`<gtk-recent-chooser-dialog>'. Most applications will only need to use
the latter; you can use `<gtk-recent-chooser-widget>' as part of a
larger window if you have special needs.

   Note that `<gtk-recent-chooser-widget>' does not have any methods of
its own. Instead, you should use the functions that work on a
`<gtk-recent-chooser>'.

   Recently used files are supported since GTK+ 2.10.

155.2 Usage
===========

 -- Class: <gtk-recent-chooser-widget>
     Derives from `<gtk-recent-chooser>', `<gtk-vbox>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-recent-chooser-widget-new =>  (ret `<gtk-widget>')
     Creates a new `<gtk-recent-chooser-widget>' object. This is an
     embeddable widget used to access the recently used resources list.

    RET
          a new `<gtk-recent-chooser-widget>'


     Since 2.10



File: guile-gnome-gtk.info,  Node: GtkRecentFilter,  Next: Undocumented,  Prev: GtkRecentChooserWidget,  Up: Top

156 GtkRecentFilter
*******************

A filter for selecting a subset of recently used files

156.1 Overview
==============

A `<gtk-recent-filter>' can be used to restrict the files being shown
in a `<gtk-recent-chooser>'. Files can be filtered based on their name
(with `gtk-recent-filter-add-pattern'), on their mime type (with
`gtk-file-filter-add-mime-type'), on the application that has registered
them (with `gtk-recent-filter-add-application'), or by a custom filter
function (with `gtk-recent-filter-add-custom').

   Filtering by mime type handles aliasing and subclassing of mime
types; e.g. a filter for text/plain also matches a file with mime type
application/rtf, since application/rtf is a subclass of text/plain.
Note that `<gtk-recent-filter>' allows wildcards for the subtype of a
mime type, so you can e.g. filter for image/*.

   Normally, filters are used by adding them to a
`<gtk-recent-chooser>', see `gtk-recent-chooser-add-filter', but it is
also possible to manually use a filter on a file with
`gtk-recent-filter-filter'.

   Recently used files are supported since GTK+ 2.10.

156.2 Usage
===========

 -- Class: <gtk-recent-filter>
     Derives from `<gtk-object>'.

     This class defines no properties, other than those defined by its
     superclasses.


 -- Function: gtk-recent-filter-new =>  (ret `<gtk-recent-filter>')
     Creates a new `<gtk-recent-filter>' with no rules added to it.
     Such filter does not accept any recently used resources, so is not
     particularly useful until you add rules with
     `gtk-recent-filter-add-pattern', `gtk-recent-filter-add-mime-type',
     `gtk-recent-filter-add-application', `gtk-recent-filter-add-age'.
     To create a filter that accepts any recently used resource, use:


          GtkRecentFilter *filter = gtk_recent_filter_new ();
          gtk_recent_filter_add_pattern (filter, "*");

    RET
          a new `<gtk-recent-filter>'


     Since 2.10


 -- Function: gtk-recent-filter-get-name (self `<gtk-recent-filter>')
          =>  (ret `mchars')
 -- Method: get-name
     Gets the human-readable name for the filter. See
     `gtk-recent-filter-set-name'.

    FILTER
          a `<gtk-recent-filter>'

    RET
          the name of the filter, or ``#f''. The returned string is
          owned by the filter object and should not be freed.


     Since 2.10


 -- Function: gtk-recent-filter-set-name (self `<gtk-recent-filter>')
          (name `mchars')
 -- Method: set-name
     Sets the human-readable name of the filter; this is the string
     that will be displayed in the recently used resources selector
     user interface if there is a selectable list of filters.

    FILTER
          a `<gtk-recent-filter>'

    NAME
          then human readable name of FILTER


     Since 2.10


 -- Function: gtk-recent-filter-add-mime-type
          (self `<gtk-recent-filter>') (mime_type `mchars')
 -- Method: add-mime-type
     Adds a rule that allows resources based on their registered MIME
     type.

    FILTER
          a `<gtk-recent-filter>'

    MIME-TYPE
          a MIME type


     Since 2.10


 -- Function: gtk-recent-filter-add-pattern
          (self `<gtk-recent-filter>') (pattern `mchars')
 -- Method: add-pattern
     Adds a rule that allows resources based on a pattern matching
     their display name.

    FILTER
          a `<gtk-recent-filter>'

    PATTERN
          a file pattern


     Since 2.10


 -- Function: gtk-recent-filter-add-application
          (self `<gtk-recent-filter>') (application `mchars')
 -- Method: add-application
     Adds a rule that allows resources based on the name of the
     application that has registered them.

    FILTER
          a `<gtk-recent-filter>'

    APPLICATION
          an application name


     Since 2.10


 -- Function: gtk-recent-filter-add-group (self `<gtk-recent-filter>')
          (group `mchars')
 -- Method: add-group
     Adds a rule that allows resources based on the name of the group
     to which they belong

    FILTER
          a `<gtk-recent-filter>'

    GROUP
          a group name


     Since 2.10


 -- Function: gtk-recent-filter-add-age (self `<gtk-recent-filter>')
          (days `int')
 -- Method: add-age
     Adds a rule that allows resources based on their age - that is,
     the number of days elapsed since they were last modified.

    FILTER
          a `<gtk-recent-filter>'

    DAYS
          number of days


     Since 2.10


 -- Function: gtk-recent-filter-get-needed (self `<gtk-recent-filter>')
          =>  (ret `<gtk-recent-filter-flags>')
 -- Method: get-needed
     Gets the fields that need to be filled in for the structure passed
     to `gtk-recent-filter-filter'

     This function will not typically be used by applications; it is
     intended principally for use in the implementation of
     `<gtk-recent-chooser>'.

    FILTER
          a `<gtk-recent-filter>'

    RET
          bitfield of flags indicating needed fields when calling
          `gtk-recent-filter-filter'


     Since 2.10



File: guile-gnome-gtk.info,  Node: Undocumented,  Next: Type Index,  Prev: GtkRecentFilter,  Up: Top

157 Undocumented
****************

The following symbols, if any, have not been properly documented.

157.1 (gnome gtk)
=================

 -- Class: <guile-gtk-tree-model>

 -- Generic: create-tag

 -- Method: create-tag (BUFFER `<gtk-text-buffer>') (TAG-NAME `<top>')
          (PROPERTIES `<top>')...

 -- Function: gtk-stock-id nick

 -- Function: gtk-text-buffer-create-tag buffer tag-name . properties

 -- Function: gtk-tree-or-list-store-set store iter . args

 -- Generic: on-get-column-type

 -- Method: on-get-column-type (OBJ `<guile-gtk-generic-tree-model>')
          (INDEX `<top>')

 -- Generic: on-get-flags

 -- Method: on-get-flags (OBJ `<guile-gtk-generic-tree-model>')

 -- Generic: on-get-iter

 -- Method: on-get-iter (OBJ `<guile-gtk-generic-tree-model>') (PATH
          `<top>')

 -- Generic: on-get-n-columns

 -- Method: on-get-n-columns (OBJ `<guile-gtk-generic-tree-model>')

 -- Generic: on-get-path

 -- Method: on-get-path (OBJ `<guile-gtk-generic-tree-model>') (ITER
          `<top>')

 -- Generic: on-get-value

 -- Method: on-get-value (OBJ `<guile-gtk-generic-tree-model>') (ITER
          `<top>') (INDEX `<top>')

 -- Generic: on-iter-children

 -- Method: on-iter-children (OBJ `<guile-gtk-generic-tree-model>')
          (PARENT `<top>')

 -- Generic: on-iter-has-child

 -- Method: on-iter-has-child (OBJ `<guile-gtk-generic-tree-model>')
          (ITER `<top>')

 -- Generic: on-iter-n-children

 -- Method: on-iter-n-children (OBJ `<guile-gtk-generic-tree-model>')
          (ITER `<top>')

 -- Generic: on-iter-next

 -- Method: on-iter-next (OBJ `<guile-gtk-generic-tree-model>') (ITER
          `<top>')

 -- Generic: on-iter-nth-child

 -- Method: on-iter-nth-child (OBJ `<guile-gtk-generic-tree-model>')
          (PARENT `<top>') (N `<top>')

 -- Generic: on-iter-parent

 -- Method: on-iter-parent (OBJ `<guile-gtk-generic-tree-model>') (ITER
          `<top>')

157.2 (gnome gw gtk)
====================

 -- Function: %gtk-message-dialog-new

 -- Variable: <gtk-binding-set*>

 -- Variable: <gtk-radio-group*>

 -- Class: <guile-gtk-generic-tree-model>

 -- Variable: gtk-accel-group-activate

 -- Variable: gtk-accel-group-connect

 -- Variable: gtk-accel-group-connect-by-path

 -- Variable: gtk-accel-group-disconnect

 -- Variable: gtk-accel-group-disconnect-key

 -- Variable: gtk-accel-group-from-accel-closure

 -- Variable: gtk-accel-group-lock

 -- Variable: gtk-accel-group-new

 -- Variable: gtk-accel-group-unlock

 -- Variable: gtk-accel-groups-activate

 -- Function: gtk-accel-groups-from-object

 -- Variable: gtk-accel-map-add-entry

 -- Variable: gtk-accel-map-add-filter

 -- Variable: gtk-accel-map-change-entry

 -- Variable: gtk-accel-map-get

 -- Variable: gtk-accel-map-load

 -- Variable: gtk-accel-map-load-fd

 -- Variable: gtk-accel-map-lock-path

 -- Variable: gtk-accel-map-save

 -- Variable: gtk-accel-map-save-fd

 -- Variable: gtk-accel-map-unlock-path

 -- Variable: gtk-accelerator-get-default-mod-mask

 -- Variable: gtk-accelerator-get-label

 -- Variable: gtk-accelerator-name

 -- Variable: gtk-accelerator-set-default-mod-mask

 -- Variable: gtk-accelerator-valid

 -- Variable: gtk-accessible-connect-widget-destroyed

 -- Variable: gtk-action-group-add-action-with-accel

 -- Variable: gtk-action-group-set-translation-domain

 -- Variable: gtk-border-copy

 -- Variable: gtk-border-free

 -- Variable: gtk-calendar-get-display-options

 -- Variable: gtk-cell-renderer-text-set-fixed-height-from-font

 -- Variable: gtk-check-menu-item-get-draw-as-radio

 -- Variable: gtk-check-menu-item-get-inconsistent

 -- Variable: gtk-check-menu-item-new-with-mnemonic

 -- Variable: gtk-check-menu-item-set-draw-as-radio

 -- Variable: gtk-check-menu-item-set-inconsistent

 -- Variable: gtk-check-version

 -- Variable: gtk-clipboard-clear

 -- Variable: gtk-clipboard-get

 -- Variable: gtk-clipboard-get-display

 -- Variable: gtk-clipboard-get-for-display

 -- Variable: gtk-clipboard-get-owner

 -- Variable: gtk-clipboard-set-image

 -- Variable: gtk-clipboard-set-text

 -- Variable: gtk-clipboard-store

 -- Variable: gtk-clipboard-wait-for-contents

 -- Variable: gtk-clipboard-wait-for-image

 -- Variable: gtk-clipboard-wait-for-text

 -- Variable: gtk-clipboard-wait-is-image-available

 -- Variable: gtk-clipboard-wait-is-rich-text-available

 -- Variable: gtk-clipboard-wait-is-target-available

 -- Variable: gtk-clipboard-wait-is-text-available

 -- Variable: gtk-color-selection-dialog-get-cancel-button

 -- Variable: gtk-color-selection-dialog-get-colorsel

 -- Variable: gtk-color-selection-dialog-get-help-button

 -- Variable: gtk-color-selection-dialog-get-ok-button

 -- Variable: gtk-color-selection-get-current-alpha

 -- Variable: gtk-color-selection-get-current-color

 -- Variable: gtk-color-selection-get-has-opacity-control

 -- Variable: gtk-color-selection-get-previous-alpha

 -- Variable: gtk-color-selection-get-previous-color

 -- Variable: gtk-color-selection-palette-to-string

 -- Variable: gtk-color-selection-set-current-alpha

 -- Variable: gtk-color-selection-set-current-color

 -- Variable: gtk-color-selection-set-has-opacity-control

 -- Variable: gtk-color-selection-set-previous-alpha

 -- Variable: gtk-color-selection-set-previous-color

 -- Variable: gtk-combo-box-get-column-span-column

 -- Variable: gtk-combo-box-set-column-span-column

 -- Variable: gtk-container-set-reallocate-redraws

 -- Variable: gtk-dialog-get-action-area

 -- Variable: gtk-dialog-get-vbox

 -- Variable: gtk-disable-setlocale

 -- Variable: gtk-drag-check-threshold

 -- Variable: gtk-drag-dest-add-image-targets

 -- Variable: gtk-drag-dest-add-text-targets

 -- Variable: gtk-drag-dest-add-uri-targets

 -- Variable: gtk-drag-dest-get-track-motion

 -- Function: gtk-drag-dest-set

 -- Variable: gtk-drag-dest-set-proxy

 -- Variable: gtk-drag-dest-set-track-motion

 -- Variable: gtk-drag-dest-unset

 -- Function: gtk-drag-finish

 -- Function: gtk-drag-get-data

 -- Variable: gtk-drag-get-source-widget

 -- Variable: gtk-drag-highlight

 -- Variable: gtk-drag-set-icon-default

 -- Variable: gtk-drag-set-icon-name

 -- Variable: gtk-drag-set-icon-pixbuf

 -- Variable: gtk-drag-set-icon-pixmap

 -- Variable: gtk-drag-set-icon-stock

 -- Variable: gtk-drag-set-icon-widget

 -- Variable: gtk-drag-source-add-image-targets

 -- Variable: gtk-drag-source-add-text-targets

 -- Variable: gtk-drag-source-add-uri-targets

 -- Function: gtk-drag-source-set-icon

 -- Variable: gtk-drag-source-set-icon-name

 -- Variable: gtk-drag-source-set-icon-pixbuf

 -- Variable: gtk-drag-source-set-icon-stock

 -- Variable: gtk-drag-source-unset

 -- Variable: gtk-drag-unhighlight

 -- Variable: gtk-draw-insertion-cursor

 -- Variable: gtk-entry-completion-get-inline-completion

 -- Variable: gtk-entry-completion-get-minimum-key-length

 -- Variable: gtk-entry-completion-get-popup-completion

 -- Variable: gtk-entry-completion-get-popup-set-width

 -- Variable: gtk-entry-completion-get-popup-single-match

 -- Variable: gtk-entry-completion-get-text-column

 -- Variable: gtk-entry-completion-insert-action-markup

 -- Variable: gtk-entry-completion-insert-action-text

 -- Variable: gtk-entry-completion-set-inline-completion

 -- Variable: gtk-entry-completion-set-minimum-key-length

 -- Variable: gtk-entry-completion-set-popup-completion

 -- Variable: gtk-entry-completion-set-popup-set-width

 -- Variable: gtk-entry-completion-set-popup-single-match

 -- Variable: gtk-entry-completion-set-text-column

 -- Variable: gtk-entry-layout-index-to-text-index

 -- Variable: gtk-entry-text-index-to-layout-index

 -- Variable: gtk-events-pending

 -- Variable: gtk-false

 -- Function: gtk-file-chooser-add-shortcut-folder

 -- Function: gtk-file-chooser-add-shortcut-folder-uri

 -- Variable: gtk-file-chooser-button-get-focus-on-click

 -- Variable: gtk-file-chooser-button-get-width-chars

 -- Variable: gtk-file-chooser-button-new-with-backend

 -- Variable: gtk-file-chooser-button-new-with-dialog

 -- Variable: gtk-file-chooser-button-set-focus-on-click

 -- Variable: gtk-file-chooser-button-set-width-chars

 -- Variable: gtk-file-chooser-error-quark

 -- Variable: gtk-file-chooser-get-current-folder-uri

 -- Variable: gtk-file-chooser-get-do-overwrite-confirmation

 -- Variable: gtk-file-chooser-get-preview-filename

 -- Variable: gtk-file-chooser-get-preview-widget-active

 -- Variable: gtk-file-chooser-get-select-multiple

 -- Variable: gtk-file-chooser-get-use-preview-label

 -- Function: gtk-file-chooser-list-shortcut-folder-uris

 -- Function: gtk-file-chooser-list-shortcut-folders

 -- Function: gtk-file-chooser-remove-shortcut-folder

 -- Function: gtk-file-chooser-remove-shortcut-folder-uri

 -- Variable: gtk-file-chooser-set-current-folder-uri

 -- Variable: gtk-file-chooser-set-do-overwrite-confirmation

 -- Variable: gtk-file-chooser-set-preview-widget-active

 -- Variable: gtk-file-chooser-set-select-multiple

 -- Variable: gtk-file-chooser-set-use-preview-label

 -- Variable: gtk-file-chooser-widget-new-with-backend

 -- Variable: gtk-file-selection-get-select-multiple

 -- Variable: gtk-file-selection-hide-fileop-buttons

 -- Variable: gtk-file-selection-set-select-multiple

 -- Variable: gtk-file-selection-show-fileop-buttons

 -- Variable: gtk-file-selection:cancel-button

 -- Variable: gtk-file-selection:ok-button

 -- Variable: gtk-font-selection-dialog-get-font-name

 -- Variable: gtk-font-selection-dialog-get-preview-text

 -- Variable: gtk-font-selection-dialog-set-font-name

 -- Variable: gtk-font-selection-dialog-set-preview-text

 -- Variable: gtk-get-current-event-time

 -- Variable: gtk-get-default-language

 -- Variable: gtk-grab-add

 -- Variable: gtk-grab-get-current

 -- Variable: gtk-grab-remove

 -- Variable: gtk-icon-factory-add

 -- Variable: gtk-icon-factory-add-default

 -- Variable: gtk-icon-factory-lookup

 -- Variable: gtk-icon-factory-lookup-default

 -- Variable: gtk-icon-factory-new

 -- Variable: gtk-icon-factory-remove-default

 -- Variable: gtk-icon-set-add-source

 -- Variable: gtk-icon-set-copy

 -- Variable: gtk-icon-set-new

 -- Variable: gtk-icon-set-new-from-pixbuf

 -- Variable: gtk-icon-set-render-icon

 -- Variable: gtk-icon-size-from-name

 -- Variable: gtk-icon-size-get-name

 -- Function: gtk-icon-size-lookup

 -- Function: gtk-icon-size-lookup-for-settings

 -- Variable: gtk-icon-size-register

 -- Variable: gtk-icon-size-register-alias

 -- Variable: gtk-icon-source-copy

 -- Variable: gtk-icon-source-get-direction

 -- Variable: gtk-icon-source-get-direction-wildcarded

 -- Variable: gtk-icon-source-get-filename

 -- Variable: gtk-icon-source-get-icon-name

 -- Variable: gtk-icon-source-get-pixbuf

 -- Variable: gtk-icon-source-get-size

 -- Variable: gtk-icon-source-get-size-wildcarded

 -- Variable: gtk-icon-source-get-state

 -- Variable: gtk-icon-source-get-state-wildcarded

 -- Variable: gtk-icon-source-new

 -- Variable: gtk-icon-source-set-direction

 -- Variable: gtk-icon-source-set-direction-wildcarded

 -- Variable: gtk-icon-source-set-filename

 -- Variable: gtk-icon-source-set-icon-name

 -- Variable: gtk-icon-source-set-pixbuf

 -- Variable: gtk-icon-source-set-size

 -- Variable: gtk-icon-source-set-size-wildcarded

 -- Variable: gtk-icon-source-set-state

 -- Variable: gtk-icon-source-set-state-wildcarded

 -- Variable: gtk-icon-theme-add-builtin-icon

 -- Variable: gtk-icon-theme-append-search-path

 -- Variable: gtk-icon-theme-error-quark

 -- Variable: gtk-icon-theme-get-default

 -- Variable: gtk-icon-theme-get-example-icon-name

 -- Variable: gtk-icon-theme-get-for-screen

 -- Variable: gtk-icon-theme-has-icon

 -- Function: gtk-icon-theme-list-icons

 -- Function: gtk-icon-theme-load-icon

 -- Variable: gtk-icon-theme-new

 -- Variable: gtk-icon-theme-prepend-search-path

 -- Variable: gtk-icon-theme-rescan-if-needed

 -- Variable: gtk-icon-theme-set-custom-theme

 -- Variable: gtk-icon-theme-set-screen

 -- Variable: gtk-icon-view-unset-model-drag-source

 -- Variable: gtk-im-multicontext-append-menuitems

 -- Variable: gtk-image-menu-item-new-with-mnemonic

 -- Variable: gtk-main

 -- Variable: gtk-main-do-event

 -- Variable: gtk-main-iteration

 -- Function: gtk-main-iteration-do

 -- Variable: gtk-main-level

 -- Variable: gtk-main-quit

 -- Variable: gtk-menu-bar-get-child-pack-direction

 -- Variable: gtk-menu-bar-set-child-pack-direction

 -- Variable: gtk-menu-tool-button-set-arrow-tooltip

 -- Variable: gtk-page-setup-set-paper-size-and-default-margins

 -- Variable: gtk-paint-arrow

 -- Variable: gtk-paint-box

 -- Variable: gtk-paint-box-gap

 -- Variable: gtk-paint-check

 -- Variable: gtk-paint-diamond

 -- Variable: gtk-paint-expander

 -- Variable: gtk-paint-extension

 -- Variable: gtk-paint-flat-box

 -- Variable: gtk-paint-focus

 -- Variable: gtk-paint-handle

 -- Variable: gtk-paint-hline

 -- Variable: gtk-paint-layout

 -- Variable: gtk-paint-option

 -- Variable: gtk-paint-resize-grip

 -- Variable: gtk-paint-shadow

 -- Variable: gtk-paint-shadow-gap

 -- Variable: gtk-paint-slider

 -- Variable: gtk-paint-tab

 -- Variable: gtk-paint-vline

 -- Variable: gtk-paper-size-get-default-bottom-margin

 -- Variable: gtk-paper-size-get-default-left-margin

 -- Variable: gtk-paper-size-get-default-right-margin

 -- Variable: gtk-paper-size-get-default-top-margin

 -- Variable: gtk-print-context-create-pango-context

 -- Variable: gtk-print-context-create-pango-layout

 -- Variable: gtk-print-error-quark

 -- Variable: gtk-print-operation-get-default-page-setup

 -- Variable: gtk-print-operation-get-print-settings

 -- Variable: gtk-print-operation-get-status-string

 -- Variable: gtk-print-operation-preview-end-preview

 -- Variable: gtk-print-operation-preview-is-selected

 -- Variable: gtk-print-operation-preview-render-page

 -- Variable: gtk-print-operation-set-current-page

 -- Variable: gtk-print-operation-set-custom-tab-label

 -- Variable: gtk-print-operation-set-default-page-setup

 -- Variable: gtk-print-operation-set-export-filename

 -- Variable: gtk-print-operation-set-print-settings

 -- Variable: gtk-print-operation-set-show-progress

 -- Variable: gtk-print-operation-set-track-print-status

 -- Variable: gtk-print-operation-set-use-full-page

 -- Variable: gtk-print-settings-get-default-source

 -- Variable: gtk-print-settings-get-double-with-default

 -- Variable: gtk-print-settings-get-int-with-default

 -- Variable: gtk-print-settings-set-default-source

 -- Variable: gtk-progress-bar-get-orientation

 -- Variable: gtk-propagate-event

 -- Variable: gtk-radio-button-new-with-label-from-widget

 -- Variable: gtk-radio-button-new-with-mnemonic-from-widget

 -- Variable: gtk-radio-menu-item-new-with-label-from-widget

 -- Variable: gtk-radio-menu-item-new-with-mnemonic

 -- Variable: gtk-radio-menu-item-new-with-mnemonic-from-widget

 -- Function: gtk-radio-tool-button-new-from-stock

 -- Variable: gtk-radio-tool-button-new-from-widget

 -- Variable: gtk-radio-tool-button-new-with-stock-from-widget

 -- Variable: gtk-range-get-lower-stepper-sensitivity

 -- Variable: gtk-range-get-upper-stepper-sensitivity

 -- Variable: gtk-range-set-lower-stepper-sensitivity

 -- Variable: gtk-range-set-upper-stepper-sensitivity

 -- Variable: gtk-rc-add-default-file

 -- Variable: gtk-rc-find-module-in-path

 -- Variable: gtk-rc-get-im-module-file

 -- Variable: gtk-rc-get-im-module-path

 -- Variable: gtk-rc-get-module-dir

 -- Variable: gtk-rc-get-style

 -- Function: gtk-rc-get-style-by-paths

 -- Variable: gtk-rc-get-theme-dir

 -- Variable: gtk-rc-parse

 -- Variable: gtk-rc-parse-string

 -- Variable: gtk-rc-property-parse-border

 -- Variable: gtk-rc-property-parse-color

 -- Variable: gtk-rc-property-parse-enum

 -- Variable: gtk-rc-property-parse-flags

 -- Variable: gtk-rc-property-parse-requisition

 -- Variable: gtk-rc-reparse-all

 -- Variable: gtk-rc-reparse-all-for-settings

 -- Variable: gtk-rc-reset-styles

 -- Function: gtk-rc-set-default-files

 -- Variable: gtk-rc-style-copy

 -- Variable: gtk-rc-style-new

 -- Variable: gtk-recent-chooser-error-quark

 -- Variable: gtk-recent-chooser-get-select-multiple

 -- Variable: gtk-recent-chooser-get-show-not-found

 -- Variable: gtk-recent-chooser-menu-get-show-numbers

 -- Variable: gtk-recent-chooser-menu-new-for-manager

 -- Variable: gtk-recent-chooser-menu-set-show-numbers

 -- Variable: gtk-recent-chooser-set-select-multiple

 -- Variable: gtk-recent-chooser-set-show-not-found

 -- Variable: gtk-recent-chooser-widget-new-for-manager

 -- Variable: gtk-recent-filter-add-pixbuf-formats

 -- Function: gtk-recent-info-get-application-info

 -- Variable: gtk-recent-manager-error-quark

 -- Variable: gtk-ruler-draw-pos

 -- Variable: gtk-ruler-draw-ticks

 -- Variable: gtk-scrolled-window-add-with-viewport

 -- Variable: gtk-selection-add-target

 -- Variable: gtk-selection-clear-targets

 -- Function: gtk-selection-convert

 -- Variable: gtk-selection-data-get-as-string

 -- Variable: gtk-selection-data-get-pixbuf

 -- Variable: gtk-selection-data-set-pixbuf

 -- Variable: gtk-selection-data-set-text

 -- Variable: gtk-selection-data-targets-include-image

 -- Variable: gtk-selection-data-targets-include-rich-text

 -- Variable: gtk-selection-data-targets-include-text

 -- Variable: gtk-selection-data-targets-include-uri

 -- Function: gtk-selection-owner-set

 -- Function: gtk-selection-owner-set-for-display

 -- Variable: gtk-selection-remove-all

 -- Variable: gtk-settings-get-default

 -- Variable: gtk-settings-get-for-screen

 -- Variable: gtk-settings-install-property

 -- Variable: gtk-settings-set-double-property

 -- Variable: gtk-settings-set-long-property

 -- Variable: gtk-settings-set-string-property

 -- Variable: gtk-spin-button-get-update-policy

 -- Variable: gtk-stock-add

 -- Variable: gtk-stock-add-static

 -- Variable: gtk-stock-item-copy

 -- Function: gtk-stock-list-ids

 -- Variable: gtk-stock-lookup

 -- Variable: gtk-style-apply-default-background

 -- Variable: gtk-style-attach

 -- Variable: gtk-style-copy

 -- Variable: gtk-style-detach

 -- Variable: gtk-style-get-bg-gc

 -- Variable: gtk-style-get-black-gc

 -- Variable: gtk-style-get-fg-gc

 -- Variable: gtk-style-get-white-gc

 -- Variable: gtk-style-lookup-color

 -- Variable: gtk-style-lookup-icon-set

 -- Variable: gtk-style-new

 -- Variable: gtk-style-render-icon

 -- Variable: gtk-style-set-background

 -- Variable: gtk-text-buffer-add-selection-clipboard

 -- Variable: gtk-text-buffer-deserialize-get-can-create-tags

 -- Variable: gtk-text-buffer-deserialize-set-can-create-tags

 -- Variable: gtk-text-buffer-get-iter-at-child-anchor

 -- Variable: gtk-text-buffer-get-iter-at-line-index

 -- Variable: gtk-text-buffer-get-iter-at-line-offset

 -- Variable: gtk-text-buffer-get-selection-bounds

 -- Variable: gtk-text-buffer-insert-interactive-at-cursor

 -- Variable: gtk-text-buffer-insert-range-interactive

 -- Function: gtk-text-buffer-insert-with-tags-by-name

 -- Variable: gtk-text-buffer-register-deserialize-tagset

 -- Variable: gtk-text-buffer-register-serialize-tagset

 -- Variable: gtk-text-buffer-remove-selection-clipboard

 -- Variable: gtk-text-iter-backward-cursor-position

 -- Variable: gtk-text-iter-backward-cursor-positions

 -- Variable: gtk-text-iter-backward-sentence-start

 -- Variable: gtk-text-iter-backward-sentence-starts

 -- Variable: gtk-text-iter-backward-to-tag-toggle

 -- Variable: gtk-text-iter-backward-visible-cursor-position

 -- Variable: gtk-text-iter-backward-visible-cursor-positions

 -- Variable: gtk-text-iter-backward-visible-lines

 -- Variable: gtk-text-iter-backward-visible-word-start

 -- Variable: gtk-text-iter-backward-visible-word-starts

 -- Variable: gtk-text-iter-forward-cursor-position

 -- Variable: gtk-text-iter-forward-cursor-positions

 -- Variable: gtk-text-iter-forward-visible-cursor-position

 -- Variable: gtk-text-iter-forward-visible-cursor-positions

 -- Variable: gtk-text-iter-forward-visible-word-end

 -- Variable: gtk-text-iter-forward-visible-word-ends

 -- Variable: gtk-text-iter-get-visible-line-index

 -- Variable: gtk-text-iter-get-visible-line-offset

 -- Variable: gtk-text-iter-set-visible-line-index

 -- Variable: gtk-text-iter-set-visible-line-offset

 -- Variable: gtk-text-view-backward-display-line-start

 -- Function: gtk-text-view-buffer-to-window-coords

 -- Variable: gtk-text-view-forward-display-line-end

 -- Variable: gtk-text-view-get-border-window-size

 -- Variable: gtk-text-view-get-default-attributes

 -- Variable: gtk-text-view-get-pixels-above-lines

 -- Variable: gtk-text-view-get-pixels-below-lines

 -- Variable: gtk-text-view-get-pixels-inside-wrap

 -- Variable: gtk-text-view-set-border-window-size

 -- Variable: gtk-text-view-set-pixels-above-lines

 -- Variable: gtk-text-view-set-pixels-below-lines

 -- Variable: gtk-text-view-set-pixels-inside-wrap

 -- Function: gtk-text-view-window-to-buffer-coords

 -- Variable: gtk-toggle-tool-button-new-from-stock

 -- Variable: gtk-tool-item-get-visible-horizontal

 -- Variable: gtk-tool-item-retrieve-proxy-menu-item

 -- Variable: gtk-tool-item-set-visible-horizontal

 -- Variable: gtk-tree-drag-dest-drag-data-received

 -- Variable: gtk-tree-drag-dest-row-drop-possible

 -- Variable: gtk-tree-drag-source-drag-data-delete

 -- Variable: gtk-tree-model-filter-convert-child-iter-to-iter

 -- Variable: gtk-tree-model-filter-convert-child-path-to-path

 -- Variable: gtk-tree-model-filter-convert-iter-to-child-iter

 -- Variable: gtk-tree-model-filter-convert-path-to-child-path

 -- Variable: gtk-tree-model-filter-set-visible-column

 -- Variable: gtk-tree-model-row-has-child-toggled

 -- Variable: gtk-tree-model-sort-convert-child-iter-to-iter

 -- Variable: gtk-tree-model-sort-convert-child-path-to-path

 -- Variable: gtk-tree-model-sort-convert-iter-to-child-iter

 -- Variable: gtk-tree-model-sort-convert-path-to-child-path

 -- Variable: gtk-tree-model-sort-reset-default-sort-func

 -- Variable: gtk-tree-selection-count-selected-rows

 -- Variable: gtk-tree-sortable-has-default-sort-func

 -- Variable: gtk-tree-sortable-set-sort-column-id

 -- Variable: gtk-tree-sortable-sort-column-changed

 -- Function: gtk-tree-view-column-cell-get-position

 -- Variable: gtk-tree-view-column-cell-is-visible

 -- Variable: gtk-tree-view-column-cell-set-cell-data

 -- Variable: gtk-tree-view-column-clear-attributes

 -- Function: gtk-tree-view-column-get-cell-renderers

 -- Variable: gtk-tree-view-column-get-fixed-width

 -- Variable: gtk-tree-view-column-get-reorderable

 -- Variable: gtk-tree-view-column-get-sort-column-id

 -- Variable: gtk-tree-view-column-get-sort-indicator

 -- Variable: gtk-tree-view-column-set-cell-data-func

 -- Variable: gtk-tree-view-column-set-fixed-width

 -- Variable: gtk-tree-view-column-set-reorderable

 -- Variable: gtk-tree-view-column-set-sort-column-id

 -- Variable: gtk-tree-view-column-set-sort-indicator

 -- Variable: gtk-tree-view-unset-rows-drag-source

 -- Variable: gtk-true

 -- Function: gtk-vscrollbar-get-type

 -- Variable: gtk-widget-get-allocation

 -- Variable: gtk-widget-get-window

 -- Variable: gtk-window-set-auto-startup-notification

 -- Function: gtk-window-set-default-icon-from-file


File: guile-gnome-gtk.info,  Node: Type Index,  Next: Function Index,  Prev: Undocumented,  Up: Top

Type Index
**********

[index]
* Menu:

* <gtk-about-dialog>:                    GtkAboutDialog.      (line  36)
* <gtk-accel-label>:                     GtkAccelLabel.       (line  64)
* <gtk-accessible>:                      GtkAccessible.       (line  15)
* <gtk-action-group>:                    GtkActionGroup.      (line  35)
* <gtk-action>:                          GtkAction.           (line  51)
* <gtk-adjustment>:                      GtkAdjustment.       (line  31)
* <gtk-alignment>:                       GtkAlignment.        (line  28)
* <gtk-arrow>:                           GtkArrow.            (line  29)
* <gtk-aspect-frame>:                    GtkAspectFrame.      (line  22)
* <gtk-assistant>:                       GtkAssistant.        (line  19)
* <gtk-bin>:                             GtkBin.              (line  23)
* <gtk-box>:                             GtkBox.              (line  60)
* <gtk-button-box>:                      GtkButtonBox.        (line  39)
* <gtk-button>:                          GtkButton.           (line  23)
* <gtk-calendar>:                        GtkCalendar.         (line  33)
* <gtk-cell-editable>:                   GtkCellEditable.     (line  18)
* <gtk-cell-layout>:                     GtkCellLayout.       (line  29)
* <gtk-cell-renderer-accel>:             GtkCellRendererAccel.
                                                              (line  21)
* <gtk-cell-renderer-combo>:             GtkCellRendererCombo.
                                                              (line  30)
* <gtk-cell-renderer-pixbuf>:            GtkCellRendererPixbuf.
                                                              (line  26)
* <gtk-cell-renderer-progress>:          GtkCellRendererProgress.
                                                              (line  22)
* <gtk-cell-renderer-spin>:              GtkCellRendererSpin. (line  31)
* <gtk-cell-renderer-text>:              GtkCellRendererText. (line  23)
* <gtk-cell-renderer-toggle>:            GtkCellRendererToggle.
                                                              (line  19)
* <gtk-cell-renderer>:                   GtkCellRenderer.     (line  46)
* <gtk-cell-view>:                       GtkCellView.         (line  20)
* <gtk-check-button>:                    GtkCheckButton.      (line  23)
* <gtk-check-menu-item>:                 GtkCheckMenuItem.    (line  23)
* <gtk-color-button>:                    GtkColorButton.      (line  20)
* <gtk-color-selection-dialog>:          GtkColorSelectionDialog.
                                                              (line  19)
* <gtk-color-selection>:                 GtkColorSelection.   (line  21)
* <gtk-combo-box-entry>:                 GtkComboBoxEntry.    (line  40)
* <gtk-combo-box>:                       GtkComboBox.         (line  39)
* <gtk-container>:                       GtkContainer.        (line 107)
* <gtk-curve>:                           GtkCurve.            (line  33)
* <gtk-dialog>:                          GtkDialog.           (line  97)
* <gtk-drawing-area>:                    GtkDrawingArea.      (line  76)
* <gtk-editable>:                        GtkEditable.         (line  50)
* <gtk-entry-completion>:                GtkEntryCompletion.  (line  46)
* <gtk-entry>:                           GtkEntry.            (line  20)
* <gtk-event-box>:                       GtkEventBox.         (line  20)
* <gtk-expander>:                        GtkExpander.         (line  57)
* <gtk-file-chooser-button>:             GtkFileChooserButton.
                                                              (line  42)
* <gtk-file-chooser-dialog>:             GtkFileChooserDialog.
                                                              (line 113)
* <gtk-file-chooser-widget>:             GtkFileChooserWidget.
                                                              (line  25)
* <gtk-file-chooser>:                    GtkFileChooser.      (line 315)
* <gtk-file-filter>:                     GtkFileFilter.       (line  31)
* <gtk-file-selection>:                  GtkFileSelection.    (line  81)
* <gtk-fixed>:                           GtkFixed.            (line  50)
* <gtk-font-button>:                     GtkFontButton.       (line  19)
* <gtk-font-selection-dialog>:           GtkFontSelectionDialog.
                                                              (line  27)
* <gtk-font-selection>:                  GtkFontSelection.    (line  28)
* <gtk-frame>:                           GtkFrame.            (line  20)
* <gtk-gamma-curve>:                     GtkGammaCurve.       (line  32)
* <gtk-handle-box>:                      GtkHandleBox.        (line  35)
* <gtk-hbox>:                            GtkHBox.             (line  22)
* <gtk-hbutton-box>:                     GtkHButtonBox.       (line  32)
* <gtk-hpaned>:                          GtkHPaned.           (line  19)
* <gtk-hruler>:                          GtkHRuler.           (line  29)
* <gtk-hscale>:                          GtkHScale.           (line  23)
* <gtk-hscrollbar>:                      GtkHScrollbar.       (line  21)
* <gtk-hseparator>:                      GtkHSeparator.       (line  24)
* <gtk-icon-view>:                       GtkIconView.         (line  22)
* <gtk-im-context-simple>:               GtkIMContextSimple.  (line  15)
* <gtk-im-context>:                      GtkIMContext.        (line  15)
* <gtk-im-multicontext>:                 GtkIMMulticontext.   (line  15)
* <gtk-image-menu-item>:                 GtkImageMenuItem.    (line  21)
* <gtk-image>:                           GtkImage.            (line  93)
* <gtk-input-dialog>:                    GtkInputDialog.      (line  33)
* <gtk-invisible>:                       GtkInvisible.        (line  21)
* <gtk-item>:                            GtkItem.             (line  18)
* <gtk-label>:                           GtkLabel.            (line 103)
* <gtk-layout>:                          GtkLayout.           (line  26)
* <gtk-link-button>:                     GtkLinkButton.       (line  32)
* <gtk-list-store>:                      GtkListStore.        (line 111)
* <gtk-menu-bar>:                        GtkMenuBar.          (line  21)
* <gtk-menu-item>:                       GtkMenuItem.         (line  22)
* <gtk-menu-shell>:                      GtkMenuShell.        (line  23)
* <gtk-menu-tool-button>:                GtkMenuToolButton.   (line  23)
* <gtk-menu>:                            GtkMenu.             (line  66)
* <gtk-message-dialog>:                  GtkMessageDialog.    (line  52)
* <gtk-misc>:                            GtkMisc.             (line  28)
* <gtk-notebook>:                        GtkNotebook.         (line  26)
* <gtk-object>:                          GtkObject.           (line  79)
* <gtk-page-setup>:                      GtkPageSetup.        (line  54)
* <gtk-paned>:                           GtkPaned.            (line  55)
* <gtk-paper-size>:                      GtkPaperSize.        (line  27)
* <gtk-plug>:                            GtkPlug.             (line  26)
* <gtk-print-context>:                   GtkPrintContext.     (line  80)
* <gtk-print-operation-preview>:         GtkPrintOperation.   (line 305)
* <gtk-print-operation>:                 GtkPrintOperation.   (line  75)
* <gtk-print-settings>:                  GtkPrintSettings.    (line  28)
* <gtk-progress-bar>:                    GtkProgressBar.      (line  50)
* <gtk-radio-action>:                    GtkRadioAction.      (line  19)
* <gtk-radio-button>:                    GtkRadioButton.      (line  79)
* <gtk-radio-menu-item>:                 GtkRadioMenuItem.    (line  38)
* <gtk-radio-tool-button>:               GtkRadioToolButton.  (line  27)
* <gtk-range>:                           GtkRange.            (line  15)
* <gtk-recent-chooser-dialog>:           GtkRecentChooserDialog.
                                                              (line  51)
* <gtk-recent-chooser-menu>:             GtkRecentChooserMenu.
                                                              (line  37)
* <gtk-recent-chooser-widget>:           GtkRecentChooserWidget.
                                                              (line  27)
* <gtk-recent-chooser>:                  GtkRecentChooser.    (line  23)
* <gtk-recent-filter>:                   GtkRecentFilter.     (line  35)
* <gtk-recent-info>:                     GtkRecentManager.    (line  81)
* <gtk-recent-manager>:                  GtkRecentManager.    (line  56)
* <gtk-requisition>:                     GtkWidget.           (line 521)
* <gtk-ruler>:                           GtkRuler.            (line  30)
* <gtk-scale>:                           GtkScale.            (line  27)
* <gtk-scrollbar>:                       GtkScrollbar.        (line  28)
* <gtk-scrolled-window>:                 GtkScrolledWindow.   (line  61)
* <gtk-selection-data>:                  GtkWidget.           (line 525)
* <gtk-separator-menu-item>:             GtkSeparatorMenuItem.
                                                              (line  19)
* <gtk-separator-tool-item>:             GtkSeparatorToolItem.
                                                              (line  27)
* <gtk-separator>:                       GtkSeparator.        (line  18)
* <gtk-size-group>:                      GtkSizeGroup.        (line  50)
* <gtk-socket>:                          GtkSocket.           (line  67)
* <gtk-spin-button>:                     GtkSpinButton.       (line  82)
* <gtk-status-icon>:                     GtkStatusIcon.       (line  40)
* <gtk-statusbar>:                       GtkStatusbar.        (line  44)
* <gtk-table>:                           GtkTable.            (line  37)
* <gtk-tearoff-menu-item>:               GtkTearoffMenuItem.  (line  28)
* <gtk-text-attributes>:                 GtkTextTag.          (line 245)
* <gtk-text-buffer>:                     GtkTextBuffer.       (line  19)
* <gtk-text-child-anchor>:               GtkTextView.         (line 112)
* <gtk-text-iter>:                       GtkTextIter.         (line  19)
* <gtk-text-mark>:                       GtkTextMark.         (line  44)
* <gtk-text-tag-table>:                  GtkTextTagTable.     (line  19)
* <gtk-text-tag>:                        GtkTextTag.          (line  28)
* <gtk-text-view>:                       GtkTextView.         (line  19)
* <gtk-toggle-action>:                   GtkToggleAction.     (line  19)
* <gtk-toggle-button>:                   GtkToggleButton.     (line  58)
* <gtk-toggle-tool-button>:              GtkToggleToolButton. (line  22)
* <gtk-tool-button>:                     GtkToolButton.       (line  34)
* <gtk-tool-item>:                       GtkToolItem.         (line  23)
* <gtk-toolbar>:                         GtkToolbar.          (line  31)
* <gtk-tooltips>:                        GtkTooltips.         (line  76)
* <gtk-tree-drag-dest>:                  GtkTreeView drag-and-drop.
                                                              (line  38)
* <gtk-tree-drag-source>:                GtkTreeView drag-and-drop.
                                                              (line  31)
* <gtk-tree-iter>:                       GtkTreeModel.        (line 221)
* <gtk-tree-model-filter>:               GtkTreeModelFilter.  (line  33)
* <gtk-tree-model-sort>:                 GtkTreeModelSort.    (line 108)
* <gtk-tree-model>:                      GtkTreeModel.        (line 170)
* <gtk-tree-path>:                       GtkTreeModel.        (line 225)
* <gtk-tree-row-reference>:              GtkTreeModel.        (line 229)
* <gtk-tree-selection>:                  GtkTreeSelection.    (line  40)
* <gtk-tree-sortable>:                   GtkTreeSortable.     (line  19)
* <gtk-tree-store>:                      GtkTreeStore.        (line  22)
* <gtk-tree-view-column>:                GtkTreeViewColumn.   (line  24)
* <gtk-tree-view>:                       GtkTreeView.         (line  22)
* <gtk-ui-manager>:                      GtkUIManager.        (line 191)
* <gtk-vbox>:                            GtkVBox.             (line  23)
* <gtk-vbutton-box>:                     GtkVButtonBox.       (line  32)
* <gtk-viewport>:                        GtkViewport.         (line  15)
* <gtk-vpaned>:                          GtkVPaned.           (line  19)
* <gtk-vruler>:                          GtkVRuler.           (line  29)
* <gtk-vscale>:                          GtkVScale.           (line  22)
* <gtk-vscrollbar>:                      GtkVScrollbar.       (line  21)
* <gtk-vseparator>:                      GtkVSeparator.       (line  19)
* <gtk-widget>:                          GtkWidget.           (line  30)
* <gtk-window-group>:                    GtkWindowGroup.      (line  15)
* <gtk-window>:                          GtkWindow.           (line  15)
* <guile-gtk-generic-tree-model>:        Undocumented.        (line  92)
* <guile-gtk-tree-model>:                Undocumented.        (line  12)

