The "Add" item.
The "Apply" item.
The "Bold" item.
The "Cancel" item.
The "Caps Lock Warning" icon.
The "CD-Rom" item.
The "Clear" item.
The "Close" item.
The "Color Picker" item.
The "Connect" icon.
The "Convert" item.
The "Copy" item.
The "Cut" item.
The "Delete" item.
The "Authentication" item.
The "Error" item.
The "Information" item.
The "Question" item.
The "Warning" item.
The "Directory" icon.
The "Discard" item.
The "Disconnect" icon.
The "Drag-And-Drop" icon.
The "Drag-And-Drop multiple" icon.
The "Edit" item.
The "Execute" item.
The "File" icon.
The "Find" item.
The "Find and Replace" item.
The "Floppy" item.
The "Fullscreen" item.
The "Bottom" item.
The "First" item.
The "Last" item.
The "Top" item.
The "Back" item.
The "Down" item.
The "Forward" item.
The "Up" item.
The "Harddisk" item.
The "Help" item.
The "Home" item.
The "Indent" item.
The "Index" item.
The "Info" item.
The "Italic" item.
The "Jump to" item.
The "Center" item.
The "Fill" item.
The "Left" item.
The "Right" item.
The "Leave Fullscreen" item.
The "Media Forward" item.
The "Media Next" item.
The "Media Pause" item.
The "Media Play" item.
The "Media Previous" item.
The "Media Record" item.
The "Media Rewind" item.
The "Media Stop" item.
The "Missing image" icon.
The "Network" item.
The "New" item.
The "No" item.
The "OK" item.
The "Open" item.
The "Landscape Orientation" item.
The "Portrait Orientation" item.
The "Reverse Landscape Orientation" item.
The "Reverse Portrait Orientation" item.
The "Page Setup" item.
The "Paste" item.
The "Preferences" item.
The "Print" item.
The "Print Error" icon.
The "Print Paused" icon.
The "Print Preview" item.
The "Print Report" icon.
The "Print Warning" icon.
The "Properties" item.
The "Quit" item.
The "Redo" item.
The "Refresh" item.
The "Remove" item.
The "Revert" item.
The "Save" item.
The "Save As" item.
The "Select All" item.
The "Color" item.
The "Font" item.
The "Ascending" item.
The "Descending" item.
The "Spell Check" item.
The "Stop" item.
The "Strikethrough" item.
The "Undelete" item.
The "Underline" item.
The "Undo" item.
The "Unindent" item.
The "Yes" item.
The "Zoom 100%" item.
The "Zoom to Fit" item.
The "Zoom In" item.
The "Zoom Out" item.
Finds the first accelerator in any #GtkAccelGroup attached
to object that matches accel_key and accel_mods, and
activates that accelerator.
the #GObject, usually a #GtkWindow, on which to activate the accelerator.
accelerator keyval from a key event
keyboard state mask from a key event
Gets a list of all accel groups which are attached to object.
Gets the value set by gtk_accelerator_set_default_mod_mask().
Converts an accelerator keyval and modifier mask into a string which can be used to represent the accelerator to the user.
accelerator keyval
accelerator modifier mask
Converts an accelerator keyval and modifier mask into a string parseable by gtk_accelerator_parse(). For example, if you pass in #GDK_q and #GDK_CONTROL_MASK, this function returns "<Control>q".
If you need to display accelerators in the user interface, see gtk_accelerator_get_label().
accelerator keyval
accelerator modifier mask
Parses a string representing an accelerator. The format looks like "<Control>a" or "<Shift><Alt>F1" or "<Release>z" (the last one is for key release). The parser is fairly liberal and allows lower or upper case, and also abbreviations such as "<Ctl>" and "<Ctrl>". Key names are parsed using gdk_keyval_from_name(). For character keys the name is not the symbol, but the lowercase name, e.g. one would use "<Ctrl>minus" instead of "<Ctrl>-".
If the parse fails, accelerator_key and accelerator_mods will
be set to 0 (zero).
string representing an accelerator
Sets the modifiers that will be considered significant for keyboard accelerators. The default mod mask is #GDK_CONTROL_MASK | #GDK_SHIFT_MASK | #GDK_MOD1_MASK | #GDK_SUPER_MASK | #GDK_HYPER_MASK | #GDK_META_MASK, that is, Control, Shift, Alt, Super, Hyper and Meta. Other modifiers will by default be ignored by #GtkAccelGroup. You must include at least the three modifiers Control, Shift and Alt in any value you pass to this function.
The default mod mask should be changed on application startup, before using any accelerator groups.
accelerator modifier mask
Determines whether a given keyval and modifier mask constitute a valid keyboard accelerator. For example, the #GDK_a keyval plus #GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator. But, you can't, for instance, use the #GDK_Control_L keyval as an accelerator.
a GDK keyval
modifier mask
Returns %TRUE if dialogs are expected to use an alternative
button order on the screen screen. See
gtk_dialog_set_alternative_button_order() for more details
about alternative button order.
If you need to use this function, you should probably connect
to the ::notify:gtk-alternative-button-order signal on the
#GtkSettings object associated to screen, in order to be
notified if the button order setting changes.
Override or install a new key binding for keyval with modifiers on
binding_set.
a #GtkBindingSet to add a signal to
key value
key modifier
signal name to be bound
list of #GtkBindingArg signal arguments
Clears a binding entry.
binding set to clear an entry of
key value of binding to clear
key modifier of binding to clear
Remove a binding previously installed via
gtk_binding_entry_add_signal() on binding_set.
a #GtkBindingSet to remove an entry of
key value of binding to remove
key modifier of binding to remove
Install a binding on binding_set which causes key lookups
to be aborted, to prevent bindings from lower priority sets
to be activated.
a #GtkBindingSet to skip an entry of
key value of binding to skip
key modifier of binding to skip
Find a binding set by its globally unique name. The set_name can
either be a name used for gtk_binding_set_new() or the type name of
a class used in gtk_binding_set_by_class().
unique binding set name
Find a key binding matching keyval and modifiers and activate the
binding on object.
object to activate when binding found
key value of the binding
key modifier of the binding
Checks that the GTK+ library in use is compatible with the given version. Generally you would pass in the constants #GTK_MAJOR_VERSION, #GTK_MINOR_VERSION, #GTK_MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GTK+ the application or module was compiled against.
Compatibility is defined by two things: first the version
of the running library is newer than the version
required_major.required_minor.required_micro. Second
the running library must be binary compatible with the
version required_major.required_minor.required_micro
(same major version.)
This function is primarily for GTK+ modules; the module can call this function to check that it wasn't loaded into an incompatible version of GTK+. However, such a a check isn't completely reliable, since the module may be linked against an old version of GTK+ and calling the old version of gtk_check_version(), but still get loaded into an application using a newer version of GTK+.
the required major version.
the required minor version.
the required micro version.
Prevents gtk_init(), gtk_init_check(), gtk_init_with_args() and
gtk_parse_args() from automatically
calling
Most programs should not need to call this function.
Initiates a drag on the source side. The function only needs to be used when the application is starting drags itself, and is not needed when gtk_drag_source_set() is used.
The event is used to retrieve the timestamp that will be used internally to
grab the pointer. If event is #NULL, then GDK_CURRENT_TIME will be used.
However, you should try to pass a real event in all cases, since that can be
used by GTK+ to get information about the start position of the drag, for
example if the event is a GDK_MOTION_NOTIFY.
Generally there are three cases when you want to start a drag by hand by calling this function:
During a button-press-event handler, if you want to start a drag immediately
when the user presses the mouse button. Pass the event that you have in your
button-press-event handler.
During a motion-notify-event handler, if you want to start a drag when the mouse
moves past a certain threshold distance after a button-press. Pass the event that you
have in your motion-notify-event handler.
During a timeout handler, if you want to start a drag after the mouse button is held down for some time. Try to save the last event that you got from the mouse, using gdk_event_copy(), and pass it to this function (remember to free the event with gdk_event_free() when you are done). If you can really not pass a real event, pass #NULL instead.
the source widget.
The targets (data formats) in which the source can provide the data.
A bitmask of the allowed drag actions for this drag.
The button the user clicked to start the drag.
The event that triggered the start of the drag.
Checks to see if a mouse drag starting at (start_x, start_y) and ending
at (current_x, current_y) has passed the GTK+ drag threshold, and thus
should trigger the beginning of a drag-and-drop operation.
a #GtkWidget
X coordinate of start of drag
Y coordinate of start of drag
current X coordinate
current Y coordinate
Add the image targets supported by #GtkSelection to
the target list of the drag destination. The targets
are added with info = 0. If you need another value,
use gtk_target_list_add_image_targets() and
gtk_drag_dest_set_target_list().
Add the text targets supported by #GtkSelection to
the target list of the drag destination. The targets
are added with info = 0. If you need another value,
use gtk_target_list_add_text_targets() and
gtk_drag_dest_set_target_list().
Add the URI targets supported by #GtkSelection to
the target list of the drag destination. The targets
are added with info = 0. If you need another value,
use gtk_target_list_add_uri_targets() and
gtk_drag_dest_set_target_list().
Returns the list of targets this widget can accept from drag-and-drop.
Sets a widget as a potential drop destination, and adds default behaviors.
The default behaviors listed in flags have an effect similar
to installing default handlers for the widget's drag-and-drop signals
(#GtkWidget:drag-motion, #GtkWidget:drag-drop, ...). They all exist
for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
sufficient to connect to the widget's #GtkWidget::drag-data-received
signal to get primitive, but consistent drag-and-drop support.
Things become more complicated when you try to preview the dragged data,
as described in the documentation for #GtkWidget:drag-motion. The default
behaviors described by flags make some assumptions, that can conflict
with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
invokations of gdk_drag_status() in the context of #GtkWidget:drag-motion,
and invokations of gtk_drag_finish() in #GtkWidget:drag-data-received.
Especially the later is dramatic, when your own #GtkWidget:drag-motion
handler calls gtk_drag_get_data() to inspect the dragged data.
There's no way to set a default action here, you can use the #GtkWidget:drag-motion callback for that. Here's an example which selects the action to use depending on whether the control key is pressed or not: |[ static void drag_motion (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { GdkModifierType mask;
gdk_window_get_pointer (gtk_widget_get_window (widget), NULL, NULL, &mask); if (mask & GDK_CONTROL_MASK) gdk_drag_status (context, GDK_ACTION_COPY, time); else gdk_drag_status (context, GDK_ACTION_MOVE, time); }
@param widget a #GtkWidget
@param flags which types of default drag behavior to use
@param targets a pointer to an array of #GtkTargetEntry<!-- -->s indicating the drop types that this `widget` will accept, or %NULL. Later you can access the list with gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
@param actions a bitmask of possible actions for a drop onto this `widget`.
Sets the target types that this widget can accept from drag-and-drop. The widget must first be made into a drag destination with gtk_drag_dest_set().
a #GtkWidget that's a drag destination
list of droppable targets, or %NULL for none
Tells the widget to emit ::drag-motion and ::drag-leave events regardless of the targets and the %GTK_DEST_DEFAULT_MOTION flag.
This may be used when a widget wants to do generic actions regardless of the targets that the source offers.
a #GtkWidget that's a drag destination
whether to accept all targets
Determines the source widget for a drag.
a (destination side) drag context
Changes the default drag icon. GTK+ retains references for the arguments, and will release them when they are no longer needed.
the colormap of the icon
the image data for the icon
the transparency mask for an image, or %NULL
The X offset within widget of the hotspot.
The Y offset within widget of the hotspot.
Sets the icon for a particular drag to the default icon.
the context for a drag. (This must be called with a context for the source side of a drag)
Sets the icon for a given drag from a named themed icon. See
the docs for #GtkIconTheme for more details. Note that the
size of the icon depends on the icon theme (the icon is
loaded at the symbolic size #GTK_ICON_SIZE_DND), thus
hot_x and hot_y have to be used with care.
the context for a drag. (This must be called with a context for the source side of a drag)
name of icon to use
the X offset of the hotspot within the icon
the Y offset of the hotspot within the icon
Sets pixbuf as the icon for a given drag.
the context for a drag. (This must be called with a context for the source side of a drag)
the #GdkPixbuf to use as the drag icon.
the X offset within widget of the hotspot.
the Y offset within widget of the hotspot.
Sets pixmap as the icon for a given drag. GTK+ retains
references for the arguments, and will release them when
they are no longer needed. In general, gtk_drag_set_icon_pixbuf()
will be more convenient to use.
the context for a drag. (This must be called with a context for the source side of a drag)
the colormap of the icon
the image data for the icon
the transparency mask for the icon or %NULL for none.
the X offset within pixmap of the hotspot.
the Y offset within pixmap of the hotspot.
Sets the icon for a given drag from a stock ID.
the context for a drag. (This must be called with a context for the source side of a drag)
the ID of the stock icon to use for the drag.
the X offset within the icon of the hotspot.
the Y offset within the icon of the hotspot.
Changes the icon for a widget to a given widget. GTK+ will not destroy the icon, so if you don't want it to persist, you should connect to the "drag-end" signal and destroy it yourself.
the context for a drag. (This must be called with a context for the source side of a drag)
a toplevel window to use as an icon.
the X offset within widget of the hotspot.
the Y offset within widget of the hotspot.
Add the writable image targets supported by #GtkSelection to
the target list of the drag source. The targets
are added with info = 0. If you need another value,
use gtk_target_list_add_image_targets() and
gtk_drag_source_set_target_list().
Add the text targets supported by #GtkSelection to
the target list of the drag source. The targets
are added with info = 0. If you need another value,
use gtk_target_list_add_text_targets() and
gtk_drag_source_set_target_list().
Add the URI targets supported by #GtkSelection to
the target list of the drag source. The targets
are added with info = 0. If you need another value,
use gtk_target_list_add_uri_targets() and
gtk_drag_source_set_target_list().
Gets the list of targets this widget can provide for drag-and-drop.
Sets up a widget so that GTK+ will start a drag operation when the user clicks and drags on the widget. The widget must have a window.
a #GtkWidget
the bitmask of buttons that can start the drag
the table of targets that the drag will support, may be %NULL
the bitmask of possible actions for a drag from this widget
Sets the icon that will be used for drags from a particular widget from a pixmap/mask. GTK+ retains references for the arguments, and will release them when they are no longer needed. Use gtk_drag_source_set_icon_pixbuf() instead.
a #GtkWidget
the colormap of the icon
the image data for the icon
the transparency mask for an image.
Changes the target types that this widget offers for drag-and-drop. The widget must first be made into a drag source with gtk_drag_source_set().
a #GtkWidget that's a drag source
list of draggable targets, or %NULL for none
Draws an arrow in the given rectangle on window using the given
parameters. arrow_type determines the direction of the arrow.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
the type of arrow to draw
%TRUE if the arrow tip should be filled
x origin of the rectangle to draw the arrow in
y origin of the rectangle to draw the arrow in
width of the rectangle to draw the arrow in
height of the rectangle to draw the arrow in
Draws a box on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
x origin of the box
y origin of the box
the width of the box
the height of the box
Draws a box in window using the given style and state and shadow type,
leaving a gap in one side.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
x origin of the rectangle
y origin of the rectangle
width of the rectangle
width of the rectangle
side in which to leave the gap
starting position of the gap
width of the gap
Draws a check button indicator in the given rectangle on window with
the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
x origin of the rectangle to draw the check in
y origin of the rectangle to draw the check in
the width of the rectangle to draw the check in
the height of the rectangle to draw the check in
Draws a diamond in the given rectangle on window using the given
parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
x origin of the rectangle to draw the diamond in
y origin of the rectangle to draw the diamond in
width of the rectangle to draw the diamond in
height of the rectangle to draw the diamond in
Draws an expander as used in #GtkTreeView.
a #GtkStyle
a #GdkWindow
a state
the x position to draw the expander at
the y position to draw the expander at
the style to draw the expander in
Draws an extension, i.e. a notebook tab.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
x origin of the extension
y origin of the extension
width of the extension
width of the extension
the side on to which the extension is attached
Draws a flat box on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
x origin of the box
y origin of the box
the width of the box
the height of the box
Draws a focus indicator around the given rectangle on window using the
given style.
a #GtkStyle
a #GdkWindow
the x origin of the rectangle around which to draw a focus indicator
the y origin of the rectangle around which to draw a focus indicator
the width of the rectangle around which to draw a focus indicator
the height of the rectangle around which to draw a focus indicator
Draws a handle as used in #GtkHandleBox and #GtkPaned.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
x origin of the handle
y origin of the handle
with of the handle
height of the handle
the orientation of the handle
Draws a horizontal line from (x1, y) to (x2, y) in window
using the given style and state.
a #GtkStyle
a #GdkWindow
a state
the starting x coordinate
the ending x coordinate
the y coordinate
Draws a text caret on drawable at location. This is not a style function
but merely a convenience function for drawing the standard cursor shape.
a #GtkWidget
a #GdkDrawable
rectangle to which the output is clipped, or %NULL if the output should not be clipped
location where to draw the cursor (location->width is ignored)
if the cursor should be the primary cursor color.
whether the cursor is left-to-right or right-to-left. Should never be #GTK_TEXT_DIR_NONE
%TRUE to draw a directional arrow on the cursor. Should be %FALSE unless the cursor is split.
Draws a layout on window using the given parameters.
a #GtkStyle
a #GdkWindow
a state
whether to use the text or foreground graphics context of style
x origin
y origin
the layout to draw
Draws a radio button indicator in the given rectangle on window with
the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
x origin of the rectangle to draw the option in
y origin of the rectangle to draw the option in
the width of the rectangle to draw the option in
the height of the rectangle to draw the option in
Draws a polygon on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
an array of #GdkPoints
length of points
%TRUE if the polygon should be filled
Draws a resize grip in the given rectangle on window using the given
parameters.
a #GtkStyle
a #GdkWindow
a state
the edge in which to draw the resize grip
the x origin of the rectangle in which to draw the resize grip
the y origin of the rectangle in which to draw the resize grip
the width of the rectangle in which to draw the resize grip
the height of the rectangle in which to draw the resize grip
Draws a shadow around the given rectangle in window
using the given style and state and shadow type.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
x origin of the rectangle
y origin of the rectangle
width of the rectangle
width of the rectangle
Draws a shadow around the given rectangle in window
using the given style and state and shadow type, leaving a
gap in one side.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
x origin of the rectangle
y origin of the rectangle
width of the rectangle
width of the rectangle
side in which to leave the gap
starting position of the gap
width of the gap
Draws a slider in the given rectangle on window using the
given style and orientation.
a #GtkStyle
a #GdkWindow
a state
a shadow
the x origin of the rectangle in which to draw a slider
the y origin of the rectangle in which to draw a slider
the width of the rectangle in which to draw a slider
the height of the rectangle in which to draw a slider
the orientation to be used
Draws an option menu tab (i.e. the up and down pointing arrows)
in the given rectangle on window using the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
x origin of the rectangle to draw the tab in
y origin of the rectangle to draw the tab in
the width of the rectangle to draw the tab in
the height of the rectangle to draw the tab in
Draws a vertical line from (x, y1) to (x, y2) in window
using the given style and state.
a #GtkStyle
a #GdkWindow
a state
the starting y coordinate
the ending y coordinate
the x coordinate
Registers an error quark for #GtkFileChooser if necessary.
Obtains a copy of the event currently being processed by GTK+. For example, if you get a "clicked" signal from #GtkButton, the current event will be the #GdkEventButton that triggered the "clicked" signal. The returned event must be freed with gdk_event_free(). If there is no current event, the function returns %NULL.
If there is a current event and it has a state field, place
that state field in state and return %TRUE, otherwise return
%FALSE.
If there is a current event and it has a timestamp, return that timestamp, otherwise return %GDK_CURRENT_TIME.
Returns the #PangoLanguage for the default language currently in effect. (Note that this can change over the life of an application.) The default language is derived from the current locale. It determines, for example, whether GTK+ uses the right-to-left or left-to-right text direction.
This function is equivalent to pango_language_get_default(). See that function for details.
Returns a #GOptionGroup for the commandline arguments recognized by GTK+ and GDK. You should add this group to your #GOptionContext with g_option_context_add_group(), if you are using g_option_context_parse() to parse your commandline arguments.
whether to open the default display when parsing the commandline arguments
Looks up the icon size associated with name.
the name to look up.
Gets the canonical name of the given icon size. The returned string is statically allocated and should not be freed.
a #GtkIconSize.
Obtains the pixel size of a semantic icon size, possibly
modified by user preferences for the default #GtkSettings.
(See gtk_icon_size_lookup_for_settings().)
Normally size would be
#GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function
isn't normally needed, gtk_widget_render_icon() is the usual
way to get an icon for rendering, then just look at the size of
the rendered pixbuf. The rendered pixbuf may not even correspond to
the width/height returned by gtk_icon_size_lookup(), because themes
are free to render the pixbuf however they like, including changing
the usual size.
an icon size
Obtains the pixel size of a semantic icon size, possibly
modified by user preferences for a particular
#GtkSettings. Normally size would be
#GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function
isn't normally needed, gtk_widget_render_icon() is the usual
way to get an icon for rendering, then just look at the size of
the rendered pixbuf. The rendered pixbuf may not even correspond to
the width/height returned by gtk_icon_size_lookup(), because themes
are free to render the pixbuf however they like, including changing
the usual size.
a #GtkSettings object, used to determine which set of user preferences to used.
an icon size
Registers a new icon size, along the same lines as #GTK_ICON_SIZE_MENU, etc. Returns the integer value for the size.
name of the icon size
the icon width
the icon height
Registers alias as another name for target.
So calling gtk_icon_size_from_name() with alias as argument
will return target.
an alias for target
an existing icon size
Call this function before using any other GTK+ functions in your GUI applications. It will initialize everything needed to operate the toolkit and parses some standard command line options.
argc and argv are adjusted accordingly so your own code will
never see those standard arguments.
Note that there are some alternative ways to initialize GTK+:
if you are calling gtk_parse_args(), gtk_init_check(),
gtk_init_with_args() or g_option_context_parse() with
the option group returned by gtk_get_option_group(),
you
Address of the
This function does the same work as gtk_init() with only a single change: It does not terminate the program if the GUI can't be initialized. Instead it returns %FALSE on failure.
This way the application can fall back to some other means of communication with the user - for example a curses or command line interface.
Address of the
This function does the same work as gtk_init_check(). Additionally, it allows you to add your own commandline options, and it automatically generates nicely formatted
output. Note that your program will be terminated after writing out the help output.a pointer to the array of command line arguments.
a string which is displayed in the first line of output, after
a %NULL-terminated array of #GOptionEntrys describing the options of your program
a translation domain to use for translating the output for the options in entries and the parameter_string with gettext(), or %NULL
Draws an arrow in the given rectangle on window using the given
parameters. arrow_type determines the direction of the arrow.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
the type of arrow to draw
%TRUE if the arrow tip should be filled
x origin of the rectangle to draw the arrow in
y origin of the rectangle to draw the arrow in
width of the rectangle to draw the arrow in
height of the rectangle to draw the arrow in
Draws a box on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the box
y origin of the box
the width of the box
the height of the box
Draws a box in window using the given style and state and shadow type,
leaving a gap in one side.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle
y origin of the rectangle
width of the rectangle
width of the rectangle
side in which to leave the gap
starting position of the gap
width of the gap
Draws a check button indicator in the given rectangle on window with
the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle to draw the check in
y origin of the rectangle to draw the check in
the width of the rectangle to draw the check in
the height of the rectangle to draw the check in
Draws a diamond in the given rectangle on window using the given
parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle to draw the diamond in
y origin of the rectangle to draw the diamond in
width of the rectangle to draw the diamond in
height of the rectangle to draw the diamond in
Draws an expander as used in #GtkTreeView. x and y specify the
center the expander. The size of the expander is determined by the
"expander-size" style property of widget. (If widget is not
specified or doesn't have an "expander-size" property, an
unspecified default size will be used, since the caller doesn't
have sufficient information to position the expander, this is
likely not useful.) The expander is expander_size pixels tall
in the collapsed position and expander_size pixels wide in the
expanded position.
a #GtkStyle
a #GdkWindow
a state
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
the x position to draw the expander at
the y position to draw the expander at
the style to draw the expander in; determines whether the expander is collapsed, expanded, or in an intermediate state.
Draws an extension, i.e. a notebook tab.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the extension
y origin of the extension
width of the extension
width of the extension
the side on to which the extension is attached
Draws a flat box on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the box
y origin of the box
the width of the box
the height of the box
Draws a focus indicator around the given rectangle on window using the
given style.
a #GtkStyle
a #GdkWindow
a state
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
the x origin of the rectangle around which to draw a focus indicator
the y origin of the rectangle around which to draw a focus indicator
the width of the rectangle around which to draw a focus indicator
the height of the rectangle around which to draw a focus indicator
Draws a handle as used in #GtkHandleBox and #GtkPaned.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the handle
y origin of the handle
with of the handle
height of the handle
the orientation of the handle
Draws a horizontal line from (x1, y) to (x2, y) in window
using the given style and state.
a #GtkStyle
a #GdkWindow
a state
rectangle to which the output is clipped, or %NULL if the output should not be clipped
the widget
a style detail
the starting x coordinate
the ending x coordinate
the y coordinate
Draws a layout on window using the given parameters.
a #GtkStyle
a #GdkWindow
a state
whether to use the text or foreground graphics context of style
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin
y origin
the layout to draw
Draws a radio button indicator in the given rectangle on window with
the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle to draw the option in
y origin of the rectangle to draw the option in
the width of the rectangle to draw the option in
the height of the rectangle to draw the option in
Draws a polygon on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
an array of #GdkPoints
length of points
%TRUE if the polygon should be filled
Draws a resize grip in the given rectangle on window using the given
parameters.
a #GtkStyle
a #GdkWindow
a state
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
the edge in which to draw the resize grip
the x origin of the rectangle in which to draw the resize grip
the y origin of the rectangle in which to draw the resize grip
the width of the rectangle in which to draw the resize grip
the height of the rectangle in which to draw the resize grip
Draws a shadow around the given rectangle in window
using the given style and state and shadow type.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
clip rectangle or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle
y origin of the rectangle
width of the rectangle
width of the rectangle
Draws a shadow around the given rectangle in window
using the given style and state and shadow type, leaving a
gap in one side.
a #GtkStyle
a #GdkWindow
a state
type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle
y origin of the rectangle
width of the rectangle
width of the rectangle
side in which to leave the gap
starting position of the gap
width of the gap
Draws a slider in the given rectangle on window using the
given style and orientation.
a #GtkStyle
a #GdkWindow
a state
a shadow
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
the x origin of the rectangle in which to draw a slider
the y origin of the rectangle in which to draw a slider
the width of the rectangle in which to draw a slider
the height of the rectangle in which to draw a slider
the orientation to be used
Draws a spinner on window using the given parameters.
a #GtkStyle
a #GdkWindow
a state
clip rectangle, or %NULL if the output should not be clipped
the widget (may be %NULL)
a style detail (may be %NULL)
the nth step, a value between 0 and #GtkSpinner:num-steps
the x origin of the rectangle in which to draw the spinner
the y origin of the rectangle in which to draw the spinner
the width of the rectangle in which to draw the spinner
the height of the rectangle in which to draw the spinner
Draws a text string on window with the given parameters.
a #GtkStyle
a #GdkWindow
a state
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin
y origin
the string to draw
Draws an option menu tab (i.e. the up and down pointing arrows)
in the given rectangle on window using the given parameters.
a #GtkStyle
a #GdkWindow
a state
the type of shadow to draw
clip rectangle, or %NULL if the output should not be clipped
the widget
a style detail
x origin of the rectangle to draw the tab in
y origin of the rectangle to draw the tab in
the width of the rectangle to draw the tab in
the height of the rectangle to draw the tab in
Draws a vertical line from (x, y1) to (x, y2) in window
using the given style and state.
a #GtkStyle
a #GdkWindow
a state
rectangle to which the output is clipped, or %NULL if the output should not be clipped
the widget
a style detail
the starting y coordinate
the ending y coordinate
the x coordinate
Returns the name of the default paper size, which depends on the current locale.
Parses command line arguments, and initializes global attributes of GTK+, but does not actually open a connection to a display. (See gdk_display_open(), gdk_get_display_arg_name())
Any arguments used by GTK+ or GDK are removed from the array and
argc and argv are updated accordingly.
There is no need to call this function explicitely if you are using gtk_init(), or gtk_init_check().
a pointer to the array of command line arguments
Registers an error quark for #GtkPrintOperation if necessary.
Runs a page setup dialog, letting the user modify the values from
page_setup. If the user cancels the dialog, the returned #GtkPageSetup
is identical to the passed in page_setup, otherwise it contains the
modifications done in the dialog.
Note that this function may use a recursive mainloop to show the page setup dialog. See gtk_print_run_page_setup_dialog_async() if this is a problem.
transient parent
an existing #GtkPageSetup
a #GtkPrintSettings
Sends an event to a widget, propagating the event to parent widgets if the event remains unhandled. Events received by GTK+ from GDK normally begin in gtk_main_do_event(). Depending on the type of event, existence of modal dialogs, grabs, etc., the event may be propagated; if so, this function is used. gtk_propagate_event() calls gtk_widget_event() on each widget it decides to send the event to. So gtk_widget_event() is the lowest-level function; it simply emits the "event" and possibly an event-specific signal on a widget. gtk_propagate_event() is a bit higher-level, and gtk_main_do_event() is the highest level.
All that said, you most likely don't want to use any of these functions; synthesizing events is rarely needed. Consider asking on the mailing list for better ways to achieve your goals. For example, use gdk_window_invalidate_rect() or gtk_widget_queue_draw() instead of making up expose events.
Adds a file to the list of files to be parsed at the end of gtk_init().
the pathname to the file. If filename is not absolute, it is searched in the current directory.
Searches for a theme engine in the GTK+ search path. This function is not useful for applications and should not be used.
name of a theme engine
Looks up a file in pixmap path for the specified #GtkSettings. If the file is not found, it outputs a warning message using g_warning() and returns %NULL.
a #GtkSettings
Scanner used to get line number information for the warning message, or %NULL
name of the pixmap file to locate.
Retrieves the current list of RC files that will be parsed at the end of gtk_init().
Obtains the path to the IM modules file. See the documentation
of the
Obtains the path in which to look for IM modules. See the documentation
of the
Returns a directory in which GTK+ looks for theme engines.
For full information about the search for theme engines,
see the docs for
Creates up a #GtkStyle from styles defined in a RC file by providing the raw components used in matching. This function may be useful when creating pseudo-widgets that should be themed like widgets but don't actually have corresponding GTK+ widgets. An example of this would be items inside a GNOME canvas widget.
The action of gtk_rc_get_style() is similar to: |[ gtk_widget_path (widget, NULL, &path, NULL); gtk_widget_class_path (widget, NULL, &class_path, NULL); gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), path, class_path, G_OBJECT_TYPE (widget));
@param settings a #GtkSettings object
@param widget_path the widget path to use when looking up the style, or %NULL if no matching against the widget path should be done
@param class_path the class path to use when looking up the style, or %NULL if no matching against the class path should be done.
@param type a type that will be used along with parent types of this type when matching against class styles, or #G_TYPE_NONE
A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser() which parses
borders in the form
a #GParamSpec
the #GString to be parsed
a #GValue which must hold boxed values.
A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser() which parses a
color given either by its name or in the form
a #GParamSpec
the #GString to be parsed
a #GValue which must hold #GdkColor values.
A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses a single enumeration value.
The enumeration value can be specified by its name, its nickname or its numeric value. For consistency with flags parsing, the value may be surrounded by parentheses.
a #GParamSpec
the #GString to be parsed
a #GValue which must hold enum values.
A #GtkRcPropertyParser for use with gtk_settings_install_property_parser() or gtk_widget_class_install_style_property_parser() which parses flags.
Flags can be specified by their name, their nickname or
numerically. Multiple flags can be specified in the form
a #GParamSpec
the #GString to be parsed
a #GValue which must hold flags values.
A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser() which parses a
requisition in the form
a #GParamSpec
the #GString to be parsed
a #GValue which must hold boxed values.
If the modification time on any previously read file for the default #GtkSettings has changed, discard all style information and then reread all previously read RC files.
This function recomputes the styles for all widgets that use a particular #GtkSettings object. (There is one #GtkSettings object per #GdkScreen, see gtk_settings_get_for_screen()); It is useful when some global parameter has changed that affects the appearance of all widgets, because when a widget gets a new style, it will both redraw and recompute any cached information about its appearance. As an example, it is used when the default font size set by the operating system changes. Note that this function doesn't affect widgets that have a style set explicitely on them with gtk_widget_set_style().
Sets the list of files that GTK+ will read at the end of gtk_init().
A %NULL-terminated list of filenames.
Converts a color from RGB space to HSV. Input values must be in the [0.0, 1.0] range; output values will be in the same range.
Red
Green
Blue
The default handler for the #GtkWidget::selection-clear-event signal.
a #GtkWidget
the event
Requests the contents of a selection. When received, a "selection-received" signal will be generated.
The widget which acts as requestor
Which selection to get
Form of information desired (e.g., STRING)
Time of request (usually of triggering event) In emergency, you could use #GDK_CURRENT_TIME
Claims ownership of a given selection for a particular widget,
or, if widget is %NULL, release ownership of the selection.
a #GtkWidget, or %NULL.
an interned atom representing the selection to claim
timestamp with which to claim the selection
Claim ownership of a given selection for a particular widget, or,
if widget is %NULL, release ownership of the selection.
the #Gdkdisplay where the selection is set
new selection owner (a #GdkWidget), or %NULL.
an interned atom representing the selection to claim.
timestamp with which to claim the selection
Initializes internationalization support for GTK+. gtk_init() automatically does this, so there is typically no point in calling this function.
If you are calling this function because you changed the locale after GTK+ is was initialized, then calling this function may help a bit. (Note, however, that changing the locale after GTK+ is initialized may produce inconsistent results and is not really supported.)
In detail - sets the current locale according to the
program environment. This is the same as calling the C library function
This is a convenience function for launching the default application
to show the uri. The uri must be of a form understood by GIO (i.e. you
need to install gvfs to get support for uri schemes such as http://
or ftp://, as only local files are handled by GIO itself).
Typical examples are
This function can be used as a replacement for gnome_vfs_url_show() and gnome_url_show().
screen to show the uri on or %NULL for the default screen
the uri to show
a timestamp to prevent focus stealing.
Registers each of the stock items in items. If an item already
exists with the same stock ID as one of the items, the old item
gets replaced. The stock items are copied, so GTK+ does not hold
any pointer into items and items can be freed. Use
gtk_stock_add_static() if items is persistent and GTK+ need not
copy the array.
Retrieves a list of all known stock IDs added to a #GtkIconFactory or registered with gtk_stock_add(). The list must be freed with g_slist_free(), and each string in the list must be freed with g_free().
Sets a function to be used for translating the label of
a stock item.
If no function is registered for a translation domain, g_dgettext() is used.
The function is used for all stock items whose
translation_domain matches domain. Note that it is possible
to use strings different from the actual gettext translation domain
of your application for this, as long as your #GtkTranslateFunc uses
the correct domain when calling dgettext(). This can be useful, e.g.
when dealing with message contexts:
|[ GtkStockItem items[] = { { MY_ITEM1, NC_("odd items", "Item 1"), 0, 0, "odd-item-domain" }, { MY_ITEM2, NC_("even items", "Item 2"), 0, 0, "even-item-domain" }, };
gchar * my_translate_func (const gchar *msgid, gpointer data) { gchar *msgctxt = data;
return (gchar*)g_dpgettext2 (GETTEXT_PACKAGE, msgctxt, msgid); }
/* ... */
gtk_stock_add (items, G_N_ELEMENTS (items)); gtk_stock_set_translate_func ("odd-item-domain", my_translate_func, "odd items"); gtk_stock_set_translate_func ("even-item-domain", my_translate_func, "even items");
@param domain the translation domain for which `func` shall be used
@param func a #GtkTranslateFunc
This function frees a target table as returned by gtk_target_table_new_from_list()
a #GtkTargetEntry array
This function creates an #GtkTargetEntry array that contains the same targets as the passed %list. The returned table is newly allocated and should be freed using gtk_target_table_free() when no longer needed.
a #GtkTargetList
Determines if any of the targets in targets can be used to
provide rich text.
an array of #GdkAtoms
a #GtkTextBuffer
Create a simple window with window title window_title and
text contents dialog_text.
The window will quit any running gtk_main()-loop when destroyed, and it
will automatically be destroyed upon test function teardown.
Title of the window to be displayed.
Text inside the window to be displayed.
This function will search widget and all its descendants for a GtkLabel
widget with a text string matching label_pattern.
The label_pattern may contain asterisks '*' and question marks '?' as
placeholders, g_pattern_match() is used for the matching.
Note that locales other than "C" tend to alter (translate" label strings,
so this function is genrally only useful in test programs with
predetermined locales, see gtk_test_init() for more details.
Valid label or container widget.
Shell-glob pattern to match a label string.
This function will search siblings of base_widget and siblings of its
ancestors for all widgets matching widget_type.
Of the matching widgets, the one that is geometrically closest to
base_widget will be returned.
The general purpose of this function is to find the most likely "action"
widget, relative to another labeling widget. Such as finding a
button or text entry widget, given it's corresponding label widget.
Valid widget, part of a widget hierarchy
Type of a aearched for sibling widget
This function will search the descendants of widget for a widget
of type widget_type that has a label matching label_pattern next
to it. This is most useful for automated GUI testing, e.g. to find
the "OK" button in a dialog and synthesize clicks on it.
However see gtk_test_find_label(), gtk_test_find_sibling() and
gtk_test_widget_click() for possible caveats involving the search of
such widgets and synthesizing widget events.
Container widget, usually a GtkWindow.
Shell-glob pattern to match a label string.
Type of a aearched for label sibling widget.
Return the type ids that have been registered after calling gtk_test_register_all_types().
Force registration of all core Gtk+ and Gdk object types. This allowes to refer to any of those object types via g_type_from_name() after calling this function.
Retrive the literal adjustment value for GtkRange based
widgets and spin buttons. Note that the value returned by
this function is anything between the lower and upper bounds
of the adjustment belonging to widget, and is not a percentage
as passed in to gtk_test_slider_set_perc().
This function will adjust the slider position of all GtkRange
based widgets, such as scrollbars or scales, it'll also adjust
spin buttons. The adjustment value of these widgets is set to
a value between the lower and upper limits, according to the
percentage argument.
This function will generate a button click in the upwards or downwards
spin button arrow areas, usually leading to an increase or decrease of
spin button's value.
valid GtkSpinButton widget.
Number of the pointer button for the event, usually 1, 2 or 3.
%TRUE for upwards arrow click, %FALSE for downwards arrow click.
This function will generate a button click (button press and button
release event) in the middle of the first GdkWindow found that belongs
to widget.
For %GTK_NO_WINDOW widgets like GtkButton, this will often be an
input-only event window. For other widgets, this is usually widget->window.
Certain caveats should be considered when using this function, in
particular because the mouse pointer is warped to the button click
location, see gdk_test_simulate_button() for details.
Widget to generate a button click on.
Number of the pointer button for the event, usually 1, 2 or 3.
Keyboard modifiers the event is setup with.
This function will generate keyboard press and release events in
the middle of the first GdkWindow found that belongs to widget.
For %GTK_NO_WINDOW widgets like GtkButton, this will often be an
input-only event window. For other widgets, this is usually widget->window.
Certain caveats should be considered when using this function, in
particular because the mouse pointer is warped to the key press
location, see gdk_test_simulate_key() for details.
Widget to generate a key press and release on.
A Gdk keyboard value.
Keyboard modifiers the event is setup with.
Obtains a tree_model and path from selection data of target type
%GTK_TREE_MODEL_ROW. Normally called from a drag_data_received handler.
This function can only be used if selection_data originates from the same
process that's calling this function, because a pointer to the tree model
is being passed around. If you aren't in the same process, then you'll
get memory corruption. In the #GtkTreeDragDest drag_data_received handler,
you can assume that selection data of type %GTK_TREE_MODEL_ROW is
in from the current process. The returned path must be freed with
gtk_tree_path_free().
a #GtkSelectionData
Lets a set of row reference created by gtk_tree_row_reference_new_proxy() know that the model emitted the "rows_reordered" signal.
A #GObject
The parent path of the reordered signal
The iter pointing to the parent of the reordered
The new order of rows
The "About" item.