st_texture_cache_get_default ()

StTextureCache *
st_texture_cache_get_default (void);

st_texture_cache_load_sliced_image_file ()

ClutterActor *
st_texture_cache_load_sliced_image_file
                               (StTextureCache *cache,
                                GFile *file,
                                gint grid_width,
                                gint grid_height,
                                gint paint_scale,
                                gfloat resource_scale,
                                GFunc load_callback,
                                gpointer user_data);

This function reads a single image file which contains multiple images internally. The image file will be divided using grid_width and grid_height ; note that the dimensions of the image loaded from path should be a multiple of the specified grid dimensions.

st_texture_cache_load_sliced_image ()

ClutterActor *
st_texture_cache_load_sliced_image (StTextureCache *cache,
                                    const gchar *path,
                                    gint grid_width,
                                    gint grid_height,
                                    GFunc load_callback,
                                    gpointer user_data);

This function reads a single image file which contains multiple images internally. The image file will be divided using grid_width and grid_height ; note that the dimensions of the image loaded from path should be a multiple of the specified grid dimensions.

st_texture_cache_load_from_pixbuf ()

ClutterActor *
st_texture_cache_load_from_pixbuf (GdkPixbuf *pixbuf,
                                   int size);

Converts a GdkPixbuf into a ClutterTexture.

st_texture_cache_load_from_raw ()

ClutterActor *
st_texture_cache_load_from_raw (StTextureCache *cache,
                                const guchar *data,
                                gsize len,
                                gboolean has_alpha,
                                int width,
                                int height,
                                int rowstride,
                                int size,
                                GError **error);

Creates (or retrieves from cache) an icon based on raw pixel data.

st_texture_cache_load_file_simple ()

ClutterActor *
st_texture_cache_load_file_simple (StTextureCache *cache,
                                   const gchar *file_path);

Synchronously load an image into a texture. The texture will be cached indefinitely. On error, this function returns an empty texture and prints a warning.

st_texture_cache_bind_cairo_surface_property ()

StWidget *
st_texture_cache_bind_cairo_surface_property
                               (StTextureCache *cache,
                                GObject *object,
                                const char *property_name,
                                gint size);

Create a ClutterActor which tracks the cairo_surface_t value of a GObject property named by property_name . Unlike other methods in StTextureCache, the underlying CoglTexture is not shared by default with other invocations to this method.

If the source object is destroyed, the texture will continue to show the last value of the property.

st_texture_cache_load_gicon_with_scale ()

ClutterActor *
st_texture_cache_load_gicon_with_scale
                               (StTextureCache *cache,
                                StThemeNode *theme_node,
                                GIcon *icon,
                                gint size,
                                gint paint_scale,
                                gfloat resource_scale);

This method returns a new ClutterActor for a given GIcon. If the icon isn't loaded already, the texture will be filled asynchronously.

st_texture_cache_load_gicon ()

ClutterActor *
st_texture_cache_load_gicon (StTextureCache *cache,
                             StThemeNode *theme_node,
                             GIcon *icon,
                             gint size);

This method returns a new ClutterActor for a given GIcon. If the icon isn't loaded already, the texture will be filled asynchronously.

st_texture_cache_load_icon_name ()

ClutterActor *
st_texture_cache_load_icon_name (StTextureCache *cache,
                                 StThemeNode *theme_node,
                                 const char *name,
                                 StIconType icon_type,
                                 gint size);

Load a themed icon into a texture. See the StIconType documentation for an explanation of how icon_type affects the returned icon. The colors used for symbolic icons are derived from theme_node .

st_texture_cache_load_file_async ()

ClutterActor *
st_texture_cache_load_file_async (StTextureCache *cache,
                                  GFile *file,
                                  int available_width,
                                  int available_height,
                                  int paint_scale,
                                  gfloat resource_scale);

Asynchronously load an image. Initially, the returned texture will have a natural size of zero. At some later point, either the image will be loaded successfully and at that point size will be negotiated, or upon an error, no image will be set.

st_texture_cache_load_uri_async ()

ClutterActor *
st_texture_cache_load_uri_async (StTextureCache *cache,
                                 const gchar *uri,
                                 int available_width,
                                 int available_height);

Asynchronously load an image. Initially, the returned texture will have a natural size of zero. At some later point, either the image will be loaded successfully and at that point size will be negotiated, or upon an error, no image will be set.

st_texture_cache_load_gfile_to_cogl_texture ()

CoglTexture *
st_texture_cache_load_gfile_to_cogl_texture
                               (StTextureCache *cache,
                                GFile *file,
                                gint paint_scale,
                                gfloat resource_scale);

This function synchronously loads the given file path into a COGL texture. On error, a warning is emitted and NULL is returned.

[skip]

st_texture_cache_load_file_to_cogl_texture ()

CoglTexture *
st_texture_cache_load_file_to_cogl_texture
                               (StTextureCache *cache,
                                const gchar *file_path);

This function synchronously loads the given file path into a COGL texture. On error, a warning is emitted and NULL is returned.

[skip]

st_texture_cache_load_gfile_to_cairo_surface ()

cairo_surface_t *
st_texture_cache_load_gfile_to_cairo_surface
                               (StTextureCache *cache,
                                GFile *file,
                                gint paint_scale,
                                gfloat resource_scale);

This function synchronously loads the given file path into a cairo surface. On error, a warning is emitted and NULL is returned.

st_texture_cache_load_file_to_cairo_surface ()

cairo_surface_t *
st_texture_cache_load_file_to_cairo_surface
                               (StTextureCache *cache,
                                const gchar *file_path);

This function synchronously loads the given file path into a cairo surface. On error, a warning is emitted and NULL is returned.

StTextureCacheLoadImageCallback ()

void
(*StTextureCacheLoadImageCallback) (StTextureCache *cache,
                                    guint handle,
                                    ClutterActor *actor,
                                    gpointer user_data);

Callback from st_texture_cache_load_image_from_file_async. The handle should match the one returned by _load_image_from_file_async.

st_texture_cache_load_image_from_file_async ()

guint
st_texture_cache_load_image_from_file_async
                               (StTextureCache *cache,
                                const gchar *path,
                                gint width,
                                gint height,
                                StTextureCacheLoadImageCallback callback,
                                gpointer user_data);

This function loads an image file into a clutter actor asynchronously. This is mostly useful for situations where you want to load an image asynchronously, but don't want the actor back until it's fully loaded and sized (as opposed to load_uri_async, which provides no callback function, and leaves size negotiation to its own devices.)

The image's aspect ratio is always maintained and if both width and height are > 0 the image will never exceed these dimensions.

StTextureCacheLoader ()

CoglTexture *
(*StTextureCacheLoader) (StTextureCache *cache,
                         const char *key,
                         void *data,
                         GError **error);

See st_texture_cache_load(). Implementations should return a texture handle for the given key, or set error .

[skip]

st_texture_cache_load ()

CoglTexture *
st_texture_cache_load (StTextureCache *cache,
                       const char *key,
                       StTextureCachePolicy policy,
                       StTextureCacheLoader load,
                       void *data,
                       GError **error);

Load an arbitrary texture, caching it. The string chosen for key should be of the form "type-prefix:type-uuid". For example, "url:file:///usr/share/icons/hicolor/48x48/apps/firefox.png", or "stock-icon:gtk-ok".

[skip]

st_texture_cache_rescan_icon_theme ()

gboolean
st_texture_cache_rescan_icon_theme (StTextureCache *cache);

ST_TYPE_TEXTURE_CACHE

#define ST_TYPE_TEXTURE_CACHE                 (st_texture_cache_get_type ())

struct StTextureCache

struct StTextureCache;

enum StTextureCachePolicy

StTextureCachePrivate

typedef struct _StTextureCachePrivate StTextureCachePrivate;

The “icon-theme-changed” signal

void
user_function (StTextureCache *sttexturecache,
               gpointer        user_data)

Flags: Run Last

The “texture-file-changed” signal

void
user_function (StTextureCache *sttexturecache,
               GFile          *arg1,
               gpointer        user_data)

Flags: Run Last