Pike Module Reference:

Initializes everything needed to operate GTK

Command line arguments that might affect GTK

In contrary to the C gtk_init() function this one doesn't adjust argv to exclude GTK arguments

Checks if any events are pending. This can be used to update the GUI and invoke timeouts etc. while doing some time intensive computation.

1 if events are pending, 0 otherwise

Calls gdk_flush()

Runs the main loop until main_quit() is called. You can nest calls to main(). In that case main_quit() will make the innermost invocation of the main loop return.

Makes the innermost invocation of the main loop return when it regains control.

Base class for all widgets

Signal Prototypes

"accel-closures-changed" void user_function (Widget object, mixed user_data)

"grab-focus" void user_function (Widget object, mixed user_data)

Recursively shows a widget, and any child widgets (if the widget is a container).

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

Reverses the effects of show(), causing the widget to be hidden (invisible to the user).

Recursively hides a widget and any child widgets.

This function is only for use in widget implementations. Causes a widget to be mapped if it isn't already.

This function is only for use in widget implementations. Causes a widget to be unmapped if it's currently mapped.

Creates the GDK (windowing system) resources associated with a widget. 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 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.

This function is only useful in widget implementations. Causes a widget to be unrealized (frees all GDK resources associated with the widget).

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.

1 to make a widget sensitive

Destroys a widget. 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 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().

FIXME: implement g_object_ref() FIXME: convince me not to implement 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.

Base class for HSeparator and VSeparator

A widget that creates a signal when clicked on.

Object Hierarchy

Object -> Widget -> Container -> Bin -> Button

Signal Prototypes

"activate" void user_function (Button dialog, mixed user_data)

The "activate" signal on GtkButton is an action signal and emitting it causes the button to animate press then release. Applications should never connect to this signal, but use the "clicked" signal.

"clicked" void user_function (Button dialog, mixed user_data)

Emitted when a button clicked on by the mouse and the cursor stays on the button. If the cursor is not on the button when the mouse button is released, the signal is not emitted.

"enter" void user_function (Button dialog, mixed user_data)

Emitted when the mouse cursor enters the region of the button.

"leave" void user_function (Button dialog, mixed user_data)

Emitted when the mouse cursor leaves the region of the button.

"pressed" void user_function (Button dialog, mixed user_data)

Emitted when the button is initially pressed.

"released" void user_function (Button dialog, mixed user_data)

Emitted when a button which is pressed is released, no matter where the mouse cursor is.

create() creates a plain button to which you can add other Widgets using add(Widget w) create(string label) creates a button with the given text

the text on the button

whether the character after an underscore ('_') should be interpreted as a mnemonic

Sets the label of the button

the new label

Returns the current label of the button, or 0 if not set

A widget that displays a small to medium amount of text.

Creates a new label with the given text inside it

text of the label

Sets the text within the GtkLabel widget. It overwrites any text that was there before. This will also clear any previously set mnemonic accelerators

the text you want to set

Fetches the text from a label widget, as displayed on the screen. This does not include any embedded underlines indicating mnemonics

Base class for widgets which contain other widgets

Object Hierarchy

Object -> Widget -> Container

Signal Prototypes

"add" void user_function (Container container, Widget widget, mixed user_data)

"check-resize" void user_function (Container container, mixed user_data)

"remove" void user_function (Container container, Widget widget, mixed user_data)

"set-focus-child" void user_function (Container container, Widget widget, mixed user_data)

Adds widget to this Container. Typically used for simple containers such as Window, Frame, or Button; for more complicated layout containers such as Box or Table, this function will pick default packing parameters that may not be correct. So consider functions such as Box->pack_start() and Table->attach() as an alternative to 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.

FIXME: implement Frame, Button, Box, Table

Removes widget from this Container. widget must be inside this Container. Note that this 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 destroy() since this will remove it from the container and help break any circular reference count cycles.

FIXME: implement g_object_ref();

A vertical separator

Creates a new VSeparator

A horizontal separator

Creates a new HSeparator

A container which allows you to position widgets at fixed coordinates

Creates a new Fixed

Adds a widget to a Fixed container at the given position.

Widget to add

the horizontal position to place the widget at

the vertical position to place the widget at

Moves a child of a Fixed container to the given position.

Widget to move

the horizontal position to move the widget to

the vertical position to move the widget to

Toplevel which can contain other widgets

Create a new Window

The title of the Window

the Window type

Sets the title of the Window. The title of a window will be displayed in its title bar; on the X Window System, the title bar is rendered by the window manager, so exactly how the title appears to users may vary according to a user's exact configuration. The title should help a user distinguish this window from other windows they may have open. A good title might include the application name and current document filename, for example.

Sets whether the user can resize a window. Windows are user resizable by default.

Gets the value set by set_resizable().

1 if the window is resizable, 0 otherwise

Activates the current focused widget within the window.

1 if a widget got activated, 0 otherwise

Sets a window modal or non-modal. Modal windows prevent interaction with other windows in the same application. To keep modal dialogs on top of main application windows, use set_transient_for() to make the dialog transient for the parent; most window managers will then disallow lowering the dialog below the parent.

Dialog windows should be set transient for the main application window they were spawned from. This allows window managers to e.g. keep the dialog on top of the main window, or center the dialog over the main window.

On Windows, this function will and put the child window on top of the parent, much as the window manager would have done on X.

If setting is 1, then destroying the transient parent of window will also destroy window itself. This is useful for dialogs that shouldn't persist beyond the lifetime of the main window they're associated with, for example.

Retrieves the title of the window.

A widget which controls the alignment and size of its child

Object Hierarchy

Object -> Widget -> Container -> Bin -> Alignment

Creates a new Alignment

the horizontal alignment of the child widget, from 0 (left) to 1 (right).

the vertical alignment of the child widget, from 0 (top) to 1 (bottom).

the amount that the child widget expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all of the space allocated for the Alignment.

the amount that the child widget expands vertically to fill up unused space, from 0 to 1. The values are similar to xscale.

Sets the Alignment values

the horizontal alignment of the child widget, from 0 (left) to 1 (right).

the vertical alignment of the child widget, from 0 (top) to 1 (bottom).

the amount that the child widget expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all of the space allocated for the Alignment.

the amount that the child widget expands vertically to fill up unused space, from 0 to 1. The values are similar to xscale.

Gets the padding for the top of the widget

the padding for the top of the widget

Gets the padding for the bottom of the widget

the padding for the bottom of the widget

Gets the padding for the left of the widget

the padding for the left of the widget

Gets the padding for the right of the widget

the padding for the right of the widget

Sets the padding on the different sides of the widget. The padding adds blank space to the sides of the widget. For instance, this can be used to indent the child widget towards the right by adding padding on the left.

the padding at the top of the widget

the padding at the bottom of the widget

the padding at the left of the widget

the padding at the right of the widget

HBox is a container that organizes child widgets into a single row.

Creates a new HBox.

whether all children are to be given equal space allotments (default: 0)

the number of pixels to place by default between children (default: 0)

The base class of the GTK+ type hierarchy.

Signal Prototypes

"destroy" void user_function (Object object,mixed user_data)

FIXME: add doc

VBox is a container that organizes child widgets into a single column.

Creates a new VBox.

whether all children are to be given equal space allotments (default: 0)

the number of pixels to place by default between children (default: 0)