gobject.type_name

    def gobject.type_name(type)

The gobject.type_name() function returns the unique name that is assigned to the specified type. type can be a GObject type, type ID or instance. This function raises a TypeError exception if type isn't a PyGTK type.

gobject.type_from_name

    def gobject.type_from_name(type_name)

The gobject.type_from_name() function returns the type ID of the PyGTK type with the name specified by type_name. This function raises a RuntimeError exception if no type matches type_name.

gobject.type_parent

    def gobject.type_parent(type)

The gobject.type_parent() function returns the direct parent type ID of the specified type. type can be a GObject type, type ID or instance. If type has no parent, i.e. is a fundamental type, the RuntimeError exception is raised.

gobject.type_is_a

    def gobject.type_is_a(type, parent_type)

The gobject.type_is_a() function returns TRUE if the specified type is a descendant of the type specified by parent_type. This function also returns TRUE if parent_type is an interface and type conforms to it.

gobject.type_children

    def gobject.type_children(type)

The gobject.type_children() function returns a list containing the child types of the specified type.

gobject.type_interfaces

    def gobject.type_interfaces(type)

The gobject.type_interfaces() function returns a list of the interface types supported by type. type can be a GObject type, type ID or instance. This function returns a RuntimeError exception if type is not a valid type or has no interfaces.

gobject.type_register

    def gobject.type_register(class)

The gobject.type_register() function registers the specified Python class as a PyGTK type. class must be a descendant of gobject.GObject. The function generates a name for the new type.

gobject.signal_new

    def gobject.signal_new(signal_name, type, flags, return_type, param_types)

The gobject.signal_new() function registers a signal with the specified signal_name for the specified object type. The value of flags is a combination of:

return_type is the type of the return value from a signal handler and may be a gobject type, type ID or instance. The param_types parameter is a list of additional types that are passed to the signal handler. Each parameter type may be specified as a gobject type, type ID or instance. For example, to add a signal to the gtk.Window type called "my-signal" that calls a handler with a gtk.Button widget and an integer value and a return value that is a boolean, use:

  gobject.signal_new("my_signal", gtk.Window, gobject.SIGNAL_RUN_LAST, gobject.TYPE_BOOLEAN, (gtk.Button, gobject.TYPE_INT))

gobject.signal_list_names

    def gobject.signal_list_names(type)

The gobject.signal_list_names() function returns a list of the names of the signals that are supported by the specified GObject type

gobject.signal_list_ids

    def gobject.signal_list_ids(type)

The gobject.signal_list_ids() function returns a list of the integer ids of the signals that are supported by the GObject specified by type

gobject.signal_lookup

    def gobject.signal_lookup(name, type)

The gobject.signal_lookup() function returns the id of the signal with the name specified by name that is supported by the GObject specified specified bytype. 0 is returned if the signal is not found.

gobject.signal_name

    def gobject.signal_name(signal_id)

The gobject.signal_name() function returns the name of the signal that has the signal id specified by id.

gobject.signal_query

    def gobject.signal_query(name, type)

The gobject.signal_query() function returns a 6-tuple containing information about the signal with the name specified by name that is supported by the GObject specified by type. If the signal is not found None is returned.

The signal information 6-tuple contains:

gobject.signal_query

    def gobject.signal_query(signal_id)

The gobject.signal_query() function returns a 6-tuple containing information about the signal with the id specified by signal_id. If the signal is not found None is returned.

The signal information 6-tuple contains:

gobject.list_properties

    def gobject.list_properties(type)

The gobject.list_properties() function returns a list of the properties (as GParam objects) supported by type.

gobject.new

    def gobject.new(type, ...)

The gobject.new() function returns a new object of the specified type. type must specify a type that is a descendant of gobject.GObject. A TypeError exception is raised if type specifies an abstract class or a type that is not a descendant of gobject.GObject. A set of property-value pairs may be specified to set the value of the object's properties.

gobject.idle_add

    def gobject.idle_add(callback, ...)

The gobject.idle_add() function adds a function (specified by callback) to be called whenever there are no higher priority events pending to the default main loop. The function is given the default idle priority, gobject.PRIORITY_DEFAULT_IDLE. Additional arguments to pass to callback can be specified after callback. The idle priority can be specified as a keyword-value pair with the keyword "priority". If callback returns FALSE it is automatically removed from the list of event sources and will not be called again.

gobject.timeout_add

    def gobject.timeout_add(interval, callback, ...)

The gobject.timeout_add() function sets a function (specified by callback) to be called at regular intervals (specified by interval, with the default priority, gobject.PRIORITY_DEFAULT. Additional arguments to pass to callback can be specified after callback. The idle priority may be specified as a keyword-value pair with the keyword "priority".

The function is called repeatedly until it returns FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The first call to the function will be at the end of the first interval. Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to 'catch up' time lost in delays).

gobject.io_add_watch

    def gobject.io_add_watch(fd, condition, callback, ...)

The gobject.io_add_watch() function arranges for the file (specified by fd) to be monitored by the main loop for the specified condition. fd may be a Python file object or an integer file descriptor. The value of condition is a combination of:

Additional arguments to pass to callback can be specified after callback. The idle priority may be specified as a keyword-value pair with the keyword "priority". The signature of the callback function is:

  def callback(source, cb_condition, ...)

where source is fd, the file descriptor; cb_condition is the condition that triggered the signal; and, ... are the zero or more arguments that were passed to the gobject.io_add_watch() function.

If the callback function returns FALSE it will be automatically removed from the list of event sources and will not be called again. If it returns TRUE it will be called again when the condition is matched.

gobject.source_remove

    def gobject.source_remove(tag)

The gobject.source_remove() function removes the event source specified by tag (as returned by the gobject.idle_add(), gobject.timeout_add() and gobject.io_add_watch() functions)

gobject.main_context_default

    def gobject.main_context_default()

The gobject.main_context_default() function returns the default gobject.MainContext object.

gobject.markup_escape_text

    def gobject.markup_escape_text(text)

The gobject.markup_escape_text() function escapes the string specified by text so that the markup parser will parse it verbatim. Less than, greater than, ampersand, etc. are replaced with the corresponding entities. This function would typically be used when writing out a file to be parsed with the markup parser.

Note that this function doesn't protect whitespace and line endings from being processed according to the XML rules for normalization of line endings and attribute values.

gobject.child_watch_add

    def gobject.child_watch_add(pid, function, data=None, priority=gobject.PRIORITY_DEFAULT)

The gobject.child_watch_add() function sets the function specified by function to be called with the user data specified by data when the child indicated by pid exits. The signature for the callback is:

def callback(pid, condition, user_data)

where pid is is the child process id, condition is the status information about the child process and user_data is data PyGTK supports only a single callback per process id.

gobject.spawn_async

    def gobject.spawn_async(argv, envp=None, working_directory=None, flags=0, child_setup=None, user_data=None, standard_input=None, standard_output=None, standard_error=None)

The gobject.spawn_async() function executes a child program asynchronously (your program will not block waiting for the child to exit). The child program is specified by the only argument that must be provided, argv. argv should be a sequence of strings, to be passed as the argument vector for the child. The first string in argv is of course the name of the program to execute. By default, the name of the program must be a full path; the PATH shell variable will only be searched if you pass the gobject.SPAWN_SEARCH_PATH flag in flags. The function returns a 4-tuple containing the child's process id and the file descriptors for the child's stdin, stdout and stderr. The stdin, stdout and stderr file descriptors are returned only ofthe corresponding standard_input, standard_output or standard_error params are TRUE.

On Windows, the low-level child process creation API (CreateProcess()) doesn't use argument vectors, but a command line. The C runtime library's spawn*() family of functions (which gobject.spawn_async() eventually calls) paste the argument vector elements into a command line, and the C runtime startup code does a corresponding reconstruction of an argument vector from the command line, to be passed to main(). Complications arise when you have argument vector elements that contain spaces of double quotes. The spawn*() functions don't do any quoting or escaping, but on the other hand the startup code does do unquoting and unescaping in order to enable receiving arguments with embedded spaces or double quotes. To work around this asymmetry, the gobject.spawn_async() function will do quoting and escaping on argument vector elements that need it before calling the C runtime spawn() function.

envp is a sequence of strings, where each string has the form KEY=VALUE. This will become the child's environment. If envp is None or not specified, the child inherits its parent's environment.

flags should be the bitwise OR of the GObject Spawn Flag Constants you want to affect the function's behaviour. The gobject.SPAWN_DO_NOT_REAP_CHILD flag means that the child will not automatically be reaped; you must use a GChildWatch source to be notified about the death of the child process. Eventually you must call g_spawn_close_pid() on the child_pid, in order to free resources which may be associated with the child process. (On Unix, using a GChildWatch source is equivalent to calling waitpid() or handling the SIGCHLD signal manually. On Windows, calling g_spawn_close_pid() is equivalent to calling CloseHandle() on the process handle returned).

gobject.SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin/stdout/stderr will be closed before calling exec() in the child. gobject.SPAWN_SEARCH_PATH means that argv[0] need not be an absolute path, it will be looked for in the user's PATH. gobject.SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will be discarded, instead of going to the same location as the parent's standard output. If you use this flag, standard_output must be None. gobject.SPAWN_STDERR_TO_DEV_NULL means that the child's standard error will be discarded, instead of going to the same location as the parent's standard error. If you use this flag, standard_error must be None. gobject.SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null). If you use this flag, standard_input must be None. gobject.SPAWN_FILE_AND_ARGV_ZERO means that the first element of argv is the file to execute, while the remaining elements are the actual argument vector to pass to the file. Normally the gobject.spawn_async() function uses argv[0] as the file to execute, and passes all of argv to the child.

child_setup and user_data are a function and user data. On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform (including creating pipes, closing file descriptors, etc.) but before calling exec(). That is, child_setup is called just before calling exec() in the child. Obviously actions taken in this function will only affect the child, not the parent. On Windows, there is no separate fork() and exec() functionality. Child processes are created and run right away with one API call, CreateProcess(). child_setup is called in the parent process just before creating the child process. You should carefully consider what you do in child_setup if you intend your software to be portable to Windows.

The returned child process id can be used to send signals to the child, or to wait for the child if you specified the gobject.SPAWN_DO_NOT_REAP_CHILD flag. On Windows, child pid will be returned only if you specified the gobject.SPAWN_DO_NOT_REAP_CHILD flag.

The caller of the gobject.spawn_async() must close any returned file descriptors when they are no longer in use.

If standard_input is None, the child's standard input is attached to /dev/null unless gobject.SPAWN_CHILD_INHERITS_STDIN is set.

If standard_error is None, the child's standard error goes to the same location as the parent's standard error unless gobject.SPAWN_STDERR_TO_DEV_NULL is set.

If standard_output is None, the child's standard output goes to the same location as the parent's standard output unless gobject.SPAWN_STDOUT_TO_DEV_NULL is set.

If an error occurs, the gobject.GError exception will be raised.

gobject.get_current_time

    def gobject.get_current_time()

The gobject.get_current_time() function reurns the current time of day as the number of seconds and microseconds from the epoch.

gobject.main_depth

    def gobject.main_depth()

The main_depth() function returns the depth of the stack of calls in the main context. That is, when called from the toplevel, it gives 0. When called from within a callback from the gobject.MainContext.iteration() method (or the gobject.MainLoop.run() method, etc.) it returns 1. When called from within a callback to a recursive call to the gobject.MainContext.iteration() method), it returns 2. And so forth.