GCancellable

typedef struct _GCancellable GCancellable;

Allows actions to be cancelled.

g_cancellable_new ()

GCancellable*       g_cancellable_new                   (void);

Creates a new GCancellable object.

Applications that want to start one or more operations that should be cancellable should create a GCancellable and pass it to the operations.

One GCancellable can be used in multiple consecutive operations, but not in multiple concurrent operations.

g_cancellable_is_cancelled ()

gboolean            g_cancellable_is_cancelled          (GCancellable *cancellable);

Checks if a cancellable job has been cancelled.

g_cancellable_set_error_if_cancelled ()

gboolean            g_cancellable_set_error_if_cancelled
                                                        (GCancellable *cancellable,
                                                         GError **error);

If the cancelalble is cancelled, sets the error to notify that the operation was cancelled.

g_cancellable_get_fd ()

int                 g_cancellable_get_fd                (GCancellable *cancellable);

Gets the file descriptor for a cancellable job. This can be used to implement cancellable operations on Unix systems. The returned fd will turn readable when cancellable is cancelled.

g_cancellable_get_current ()

GCancellable*       g_cancellable_get_current           (void);

Gets the top cancellable from the stack.

g_cancellable_pop_current ()

void                g_cancellable_pop_current           (GCancellable *cancellable);

Pops cancellable off the cancellable stack (verifying that cancellable is on the top of the stack).

g_cancellable_push_current ()

void                g_cancellable_push_current          (GCancellable *cancellable);

Pushes cancellable onto the cancellable stack. The current cancllable can then be recieved using g_cancellable_get_current().

This is useful when implementing cancellable operations in code that does not allow you to pass down the cancellable object.

This is typically called automatically by e.g. GFile operations, so you rarely have to call this yourself.

g_cancellable_reset ()

void                g_cancellable_reset                 (GCancellable *cancellable);

Resets cancellable to its uncancelled state.

g_cancellable_cancel ()

void                g_cancellable_cancel                (GCancellable *cancellable);

Will set cancellable to cancelled, and will emit the CANCELLED signal.

This function is thread-safe. In other words, you can safely call it from another thread than the one running an operation that was passed the cancellable.

The "cancelled" signal

void                user_function                      (GCancellable *cancellable,
                                                        gpointer      user_data)        : Run Last

Emitted when the operation has been cancelled from another thread.

Can be used by implementations of cancellable operations. This will be emitted in the thread that tried to cancel the operation, not the thread the is running the operation.