Sets our main struct and passes it to the parent class
Acquires the device for the current thread. This function will block until no other thread has acquired the device. If the return value is CAIRO_STATUS_SUCCESS, you successfully acquired the device. From now on your thread owns the device and no other thread will be able to acquire it until a matching call to cairo_device_release(). It is allowed to recursively acquire the device multiple times from the same thread. Note You must never acquire two different devices at the same time unless this is explicitly allowed. Otherwise the possibility of deadlocks exist. As various Cairo functions can acquire devices when called, these functions may also cause deadlocks when you call them with an acquired device. So you must not have a device acquired when calling them. These functions are marked in the documentation. Since 1.10
Decreases the reference count on device by one. If the result is zero, then device and all associated resources are freed. See cairo_device_reference(). This function may acquire devices if the last reference was dropped. Since 1.10
This function finishes the device and drops all references to external resources. All surfaces, fonts and other objects created for this device will be finished, too. Further operations on the device will not affect the device but will instead trigger a CAIRO_STATUS_DEVICE_FINISHED error. When the last call to cairo_device_destroy() decreases the reference count to zero, cairo will call cairo_device_finish() if it hasn't been called already, before freeing the resources associated with the device. This function may acquire devices. Since 1.10
Finish any pending operations for the device and also restore any temporary modifications cairo has made to the device's state. This function must be called before switching from using the device with Cairo to operating on it directly with native APIs. If the device doesn't support direct access, then this function does nothing. This function may acquire devices. Since 1.10
Returns the current reference count of device. Since 1.10
the main Gtk struct as a void*
This function returns the type of the device. See cairo_device_type_t for available types. Since 1.10
Return user data previously attached to device using the specified key. If no user data has been attached with the given key this function returns NULL. Since 1.10
Increases the reference count on device by one. This prevents device from being destroyed until a matching call to cairo_device_destroy() is made. The number of references to a cairo_device_t can be get using cairo_device_get_reference_count(). Since 1.10
Releases a device previously acquired using cairo_device_acquire(). See that function for details. Since 1.10
Attach user data to device. To remove user data from a surface, call this function with the key that was used to set it and NULL for data. Since 1.10
Checks whether an error has previously occurred for this device. Since 1.10
the main Gtk struct
Devices are the abstraction Cairo employs for the rendering system used by a cairo_surface_t. You can get the device of a surface using cairo_surface_get_device().
Devices are created using custom functions specific to the rendering system you want to use. See the documentation for the surface types for those functions.
An important function that devices fulfill is sharing access to the rendering system between Cairo and your application. If you want to access a device directly that you used to draw to with Cairo, you must first call cairo_device_flush() to ensure that Cairo finishes all operations on the device and resets it to a clean state.
Cairo also provides the functions cairo_device_acquire() and cairo_device_release() to synchronize access to the rendering system in a multithreaded environment. This is done internally, but can also be used by applications.
Putting this all together, a function that works with devices should look something like this:
Note
Please refer to the documentation of each backend for additional usage requirements, guarantees provided, and interactions with existing surface API of the device functions for surfaces of that type.