Commit 276d9a93 authored by Owen W. Taylor's avatar Owen W. Taylor

Import stylesheet code from hippo-canvas

Import:

  HippoCanvasTheme      => StTheme
  HippoCanvasThemeImage => StThemeImage
  HippoCanvasStyle      => StThemeNode

StThemeContext is a new class managing the theme for a stage and
global properties like resolution.

test-theme.c is a newly written test program to do verification of the
style matching and property handling rules.

Various changes are made in the import:

 - Comprehensive reindentation
 - guint32 pixels replaced with ClutterColor
 - General pseudo-class support added
 - Old-fashioned (non-bordered) background image support added, though
   with no support for repeat, etc.
 - Bug fixes for problems revealed by test program

https://bugzilla.gnome.org/show_bug.cgi?id=595990
parent 6b958640
......@@ -38,6 +38,7 @@ src/gnomeshell-taskpanel
src/gnome-shell
src/test-recorder
src/test-recorder.ogg
src/test-theme
stamp-h1
tests/run-test.sh
xmldocs.make
......@@ -60,6 +60,7 @@ PKG_CHECK_MODULES(TIDY, clutter-1.0)
PKG_CHECK_MODULES(ST, clutter-1.0 gtk+-2.0 libccss-1 >= 0.3.1 clutter-imcontext-0.1)
PKG_CHECK_MODULES(BIG, clutter-1.0 gtk+-2.0 librsvg-2.0)
PKG_CHECK_MODULES(GDMUSER, dbus-glib-1 gtk+-2.0)
PKG_CHECK_MODULES(TOOLKIT, clutter-1.0 libcroco-0.6)
PKG_CHECK_MODULES(TRAY, gtk+-2.0)
MUTTER_BIN_DIR=`$PKG_CONFIG --variable=exec_prefix mutter-plugins`/bin
......
......@@ -73,7 +73,6 @@ st_source_h = \
st/st-clipboard.h \
st/st-entry.h \
st/st-label.h \
st/st-private.h \
st/st-stylable.h \
st/st-style.h \
st/st-scrollable.h \
......@@ -82,11 +81,19 @@ st_source_h = \
st/st-subtexture.h \
st/st-texture-cache.h \
st/st-texture-frame.h \
st/st-theme.h \
st/st-theme-context.h \
st/st-theme-image.h \
st/st-theme-node.h \
st/st-tooltip.h \
st/st-types.h \
st/st-widget.h \
$(NULL)
st_source_private_h = \
st/st-private.h \
st/st-theme-private.h
# please, keep this sorted alphabetically
st_source_c = \
st/st-adjustment.c \
......@@ -106,6 +113,10 @@ st_source_c = \
st/st-subtexture.c \
st/st-texture-cache.c \
st/st-texture-frame.c \
st/st-theme.c \
st/st-theme-context.c \
st/st-theme-image.c \
st/st-theme-node.c \
st/st-tooltip.c \
st/st-widget.c \
$(NULL)
......@@ -115,8 +126,16 @@ noinst_LTLIBRARIES += libst-1.0.la
libst_1_0_la_LIBADD = $(ST_LIBS)
libst_1_0_la_SOURCES = \
$(st_source_c) \
$(st_source_private_c) \
$(st_source_h) \
$(st_built_sources) \
$(NULL)
libst_1_0_la_CPPFLAGS = $(st_cflags)
libst_1_0_la_LDFLAGS = $(LDADD)
noinst_PROGRAMS += test-theme
test_theme_CPPFLAGS = $(st_cflags)
test_theme_LDADD = libst-1.0.la
test_theme_SOURCES = st/test-theme.c
......@@ -4,6 +4,7 @@ CLEANFILES =
EXTRA_DIST =
libexec_PROGRAMS =
noinst_LTLIBRARIES =
noinst_PROGRAMS =
.AUTOPARALLEL:
......@@ -95,7 +96,7 @@ libgnome_shell_la_SOURCES = \
shell-wm.c \
shell-wm.h
non_gir_sources = \
non_gir_sources = \
shell-embedded-window-private.h
shell_recorder_sources = \
......@@ -113,7 +114,7 @@ if BUILD_RECORDER
libgnome_shell_la_SOURCES += $(shell_recorder_sources)
non_gir_sources += $(shell_recorder_non_gir_sources)
noinst_PROGRAMS = test-recorder
noinst_PROGRAMS += test-recorder
test_recorder_CPPFLAGS = $(TEST_SHELL_RECORDER_CFLAGS)
test_recorder_LDADD = $(TEST_SHELL_RECORDER_LIBS)
......
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#include <config.h>
#include "st-theme.h"
#include "st-theme-context.h"
struct _StThemeContext {
GObject parent;
double resolution;
PangoFontDescription *font;
StThemeNode *root_node;
StTheme *theme;
};
struct _StThemeContextClass {
GObjectClass parent_class;
};
#define DEFAULT_RESOLUTION 96.
#define DEFAULT_FONT "sans-serif 10"
enum
{
CHANGED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE (StThemeContext, st_theme_context, G_TYPE_OBJECT)
static void
st_theme_context_finalize (GObject *object)
{
StThemeContext *context = ST_THEME_CONTEXT (object);
if (context->root_node)
g_object_unref (context->root_node);
if (context->theme)
g_object_unref (context->theme);
pango_font_description_free (context->font);
G_OBJECT_CLASS (st_theme_context_parent_class)->finalize (object);
}
static void
st_theme_context_class_init (StThemeContextClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = st_theme_context_finalize;
signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, /* no default handler slot */
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
st_theme_context_init (StThemeContext *context)
{
context->resolution = DEFAULT_RESOLUTION;
context->font = pango_font_description_from_string (DEFAULT_FONT);
}
/**
* st_theme_context_new:
*
* Create a new theme context not associated with any #ClutterStage.
* This can be useful in testing scenarios, or if using StThemeContext
* with something other than #ClutterActor objects, but you generally
* should use st_theme_context_get_for_stage() instead.
*/
StThemeContext *
st_theme_context_new (void)
{
StThemeContext *context;
context = g_object_new (ST_TYPE_THEME_CONTEXT, NULL);
return context;
}
static void
on_stage_destroy (ClutterStage *stage)
{
StThemeContext *context = st_theme_context_get_for_stage (stage);
g_object_set_data (G_OBJECT (stage), "st-theme-context", NULL);
g_object_unref (context);
}
static void
st_theme_context_changed (StThemeContext *context)
{
StThemeNode *old_root = context->root_node;
context->root_node = NULL;
g_signal_emit (context, signals[CHANGED], 0);
if (old_root)
g_object_unref (old_root);
}
/**
* st_theme_context_get_for_stage:
* @stage: a #ClutterStage
*
* Gets a singleton theme context associated with the stage.
*
* Return value: (transfer none): the singleton theme context for the stage
*/
StThemeContext *
st_theme_context_get_for_stage (ClutterStage *stage)
{
StThemeContext *context;
g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL);
context = g_object_get_data (G_OBJECT (stage), "st-theme-context");
if (context)
return context;
context = st_theme_context_new ();
g_object_set_data (G_OBJECT (stage), "st-theme-context", context);
g_signal_connect (stage, "destroy",
G_CALLBACK (on_stage_destroy), NULL);
return context;
}
/**
* st_theme_context_set_theme:
* @context: a #StThemeContext
*
* Sets the default set of theme stylesheets for the context. This theme will
* be used for the root node and for nodes descending from it, unless some other
* style is explicitely specified.
*/
void
st_theme_context_set_theme (StThemeContext *context,
StTheme *theme)
{
g_return_if_fail (ST_IS_THEME_CONTEXT (context));
g_return_if_fail (theme == NULL || ST_IS_THEME (theme));
if (context->theme != theme)
{
if (context->theme)
g_object_unref (context->theme);
context->theme = theme;
if (context->theme)
g_object_ref (context->theme);
st_theme_context_changed (context);
}
}
/**
* st_theme_context_get_theme:
* @context: a #StThemeContext
*
* Gets the default theme for the context. See st_theme_context_set_theme()
*
* Return value: (transfer none): the default theme for the context
*/
StTheme *
st_theme_context_get_theme (StThemeContext *context)
{
g_return_val_if_fail (ST_IS_THEME_CONTEXT (context), NULL);
return context->theme;
}
/**
* st_theme_context_set_resolution:
* @context: a #StThemeContext
* @resolution: resolution of the context (number of pixels in an "inch")
*
* Sets the resolution of the theme context. This is the scale factor
* used to convert between points and the length units pt, in, and cm.
* This does not necessarily need to correspond to the actual number
* resolution of the device. A value of 72. means that points and
* pixels are identical. The default value is 96.
*/
void
st_theme_context_set_resolution (StThemeContext *context,
double resolution)
{
g_return_if_fail (ST_IS_THEME_CONTEXT (context));
if (resolution == context->resolution)
return;
context->resolution = resolution;
st_theme_context_changed (context);
}
/**
* st_theme_context_set_resolution:
* @context: a #StThemeContext
*
* Gets the current resolution of the theme context.
* See st_theme_context_set_resolution().
*
* Return value: the resolution (in dots-per-"inch")
*/
double
st_theme_context_get_resolution (StThemeContext *context)
{
g_return_val_if_fail (ST_IS_THEME_CONTEXT (context), DEFAULT_RESOLUTION);
return context->resolution;
}
/**
* st_theme_context_set_font:
* @context: a #StThemeContext
* @font: the default font for theme context
*
* Sets the default font for the theme context. This is the font that
* is inherited by the root node of the tree of theme nodes. If the
* font is not overriden, then this font will be used. If the font is
* partially modified (for example, with 'font-size: 110%', then that
* modification is based on this font.
*/
void
st_theme_context_set_font (StThemeContext *context,
const PangoFontDescription *font)
{
g_return_if_fail (ST_IS_THEME_CONTEXT (context));
g_return_if_fail (font != NULL);
if (context->font == font ||
pango_font_description_equal (context->font, font))
return;
pango_font_description_free (context->font);
context->font = pango_font_description_copy (font);
st_theme_context_changed (context);
}
/**
* st_theme_context_get_font:
* @context: a #StThemeContext
*
* Gets the default font for the theme context. See st_theme_context_set_font().
*
* Return value: the default font for the theme context.
*/
const PangoFontDescription *
st_theme_context_get_font (StThemeContext *context)
{
g_return_val_if_fail (ST_IS_THEME_CONTEXT (context), NULL);
return context->font;
}
/**
* st_theme_context_get_root_node:
* @context: a #StThemeContext
*
* Gets the root node of the tree of theme style nodes that associated with this
* context. For the node tree associated with a stage, this node represents
* styles applied to the stage itself.
*
* Return value: (transfer none): the root node of the context's style tree
*/
StThemeNode *
st_theme_context_get_root_node (StThemeContext *context)
{
if (context->root_node == NULL)
context->root_node = st_theme_node_new (context, NULL, context->theme,
G_TYPE_NONE, NULL, NULL, NULL);
return context->root_node;
}
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#ifndef __ST_THEME_CONTEXT_H__
#define __ST_THEME_CONTEXT_H__
#include <clutter/clutter.h>
#include <pango/pango.h>
#include "st-theme-node.h"
G_BEGIN_DECLS
/**
* SECTION:StThemeContext
* @short_description: holds global information about a tree of styled objects
*
* #StThemeContext is responsible for managing information global to a tree of styled objects,
* such as the set of stylesheets or the default font. In normal usage, a #StThemeContext
* is bound to a #ClutterStage; a singleton #StThemeContext can be obtained for a #ClutterStage
* by using st_theme_context_get_for_stage().
*/
typedef struct _StThemeContextClass StThemeContextClass;
#define ST_TYPE_THEME_CONTEXT (st_theme_context_get_type ())
#define ST_THEME_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME_CONTEXT, StThemeContext))
#define ST_THEME_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME_CONTEXT, StThemeContextClass))
#define ST_IS_THEME_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME_CONTEXT))
#define ST_IS_THEME_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME_CONTEXT))
#define ST_THEME_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME_CONTEXT, StThemeContextClass))
GType st_theme_context_get_type (void) G_GNUC_CONST;
StThemeContext *st_theme_context_new (void);
StThemeContext *st_theme_context_get_for_stage (ClutterStage *stage);
void st_theme_context_set_theme (StThemeContext *context,
StTheme *theme);
StTheme * st_theme_context_get_theme (StThemeContext *context);
void st_theme_context_set_resolution (StThemeContext *context,
gdouble resolution);
double st_theme_context_get_resolution (StThemeContext *context);
void st_theme_context_set_font (StThemeContext *context,
const PangoFontDescription *font);
const PangoFontDescription *st_theme_context_get_font (StThemeContext *context);
StThemeNode * st_theme_context_get_root_node (StThemeContext *context);
G_END_DECLS
#endif /* __ST_THEME_CONTEXT_H__ */
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#include <config.h>
#include "st-theme-image.h"
struct _StThemeImage {
GObject parent;
char *filename;
int border_top;
int border_right;
int border_bottom;
int border_left;
};
struct _StThemeImageClass {
GObjectClass parent_class;
};
G_DEFINE_TYPE (StThemeImage, st_theme_image, G_TYPE_OBJECT)
static void
st_theme_image_finalize (GObject *object)
{
StThemeImage *image = ST_THEME_IMAGE (object);
g_free (image->filename);
G_OBJECT_CLASS (st_theme_image_parent_class)->finalize (object);
}
static void
st_theme_image_class_init (StThemeImageClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = st_theme_image_finalize;
}
static void
st_theme_image_init (StThemeImage *image)
{
}
StThemeImage *
st_theme_image_new (const char *filename,
int border_top,
int border_right,
int border_bottom,
int border_left)
{
StThemeImage *image;
image = g_object_new (ST_TYPE_THEME_IMAGE, NULL);
image->filename = g_strdup (filename);
image->border_top = border_top;
image->border_right = border_right;
image->border_bottom = border_bottom;
image->border_left = border_left;
return image;
}
const char *
st_theme_image_get_filename (StThemeImage *image)
{
g_return_val_if_fail (ST_IS_THEME_IMAGE (image), NULL);
return image->filename;
}
void
st_theme_image_get_borders (StThemeImage *image,
int *border_top,
int *border_right,
int *border_bottom,
int *border_left)
{
g_return_if_fail (ST_IS_THEME_IMAGE (image));
if (border_top)
*border_top = image->border_top;
if (border_right)
*border_right = image->border_right;
if (border_bottom)
*border_bottom = image->border_bottom;
if (border_left)
*border_left = image->border_left;
}
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#ifndef __ST_THEME_IMAGE_H__
#define __ST_THEME_IMAGE_H__
#include <glib-object.h>
G_BEGIN_DECLS
/* A StThemeImage encapsulates an image with specified unscaled borders on each edge.
*/
typedef struct _StThemeImage StThemeImage;
typedef struct _StThemeImageClass StThemeImageClass;
#define ST_TYPE_THEME_IMAGE (st_theme_image_get_type ())
#define ST_THEME_IMAGE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME_IMAGE, StThemeImage))
#define ST_THEME_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME_IMAGE, StThemeImageClass))
#define ST_IS_THEME_IMAGE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME_IMAGE))
#define ST_IS_THEME_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME_IMAGE))
#define ST_THEME_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME_IMAGE, StThemeImageClass))
GType st_theme_image_get_type (void) G_GNUC_CONST;
StThemeImage *st_theme_image_new (const char *filename,
int border_top,
int border_right,
int border_bottom,
int border_left);
const char *st_theme_image_get_filename (StThemeImage *image);
void st_theme_image_get_borders (StThemeImage *image,
int *border_top,
int *border_right,
int *border_bottom,
int *border_left);
G_END_DECLS
#endif /* __ST_THEME_IMAGE_H__ */
This diff is collapsed.
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#ifndef __ST_THEME_NODE_H__
#define __ST_THEME_NODE_H__
#include <clutter/clutter.h>
#include "st-theme-image.h"
G_BEGIN_DECLS
/**
* SECTION:StThemeNode
* @short_description: style information for one node in a tree of themed objects
*
* A #StThemeNode represents the CSS style information (the set of CSS properties) for one
* node in a tree of themed objects. In typical usage, it represents the style information
* for a single #ClutterActor. A #StThemeNode is immutable: attributes such as the
* CSS classes for the node are passed in at construction. If the attributes of the node
* or any parent node change, the node should be discarded and a new node created.
* #StThemeNode has generic accessors to look up properties by name and specific
* accessors for standard CSS properties that add caching and handling of various
* details of the CSS specification. #StThemeNode also has convenience functions to help
* in implementing a #ClutterActor with borders and padding.
*/
typedef struct _StTheme StTheme;
typedef struct _StThemeContext StThemeContext;
typedef struct _StThemeNode StThemeNode;
typedef struct _StThemeNodeClass StThemeNodeClass;
#define ST_TYPE_THEME_NODE (st_theme_node_get_type ())
#define ST_THEME_NODE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME_NODE, StThemeNode))
#define ST_THEME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME_NODE, StThemeNodeClass))
#define ST_IS_THEME_NODE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME_NODE))
#define ST_IS_THEME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME_NODE))
#define ST_THEME_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME_NODE, StThemeNodeClass))
typedef enum {
ST_SIDE_LEFT,
ST_SIDE_RIGHT,
ST_SIDE_TOP,
ST_SIDE_BOTTOM
} StSide;
/* These are the CSS values; that doesn't mean we have to implement blink... */
typedef enum {
ST_TEXT_DECORATION_UNDERLINE = 1 << 0,
ST_TEXT_DECORATION_OVERLINE = 1 << 1,
ST_TEXT_DECORATION_LINE_THROUGH = 1 << 2,
ST_TEXT_DECORATION_BLINK = 1 << 3
} StTextDecoration;
GType st_theme_node_get_type (void) G_GNUC_CONST;
StThemeNode *st_theme_node_new (StThemeContext *context,
StThemeNode *parent_node, /* can be null */
StTheme *theme, /* can be null */
GType element_type,
const char *element_id,
const char *element_class,
const char *pseudo_class);
StThemeNode *st_theme_node_get_parent (StThemeNode *node);
StTheme *st_theme_node_get_theme (StThemeNode *node);
GType st_theme_node_get_element_type (StThemeNode *node);
const char *st_theme_node_get_element_id (StThemeNode *node);
const char *st_theme_node_get_element_class (StThemeNode *node);
const char *st_theme_node_get_pseudo_class (StThemeNode *node);
/* Generic getters ... these are not cached so are less efficient. The other
* reason for adding the more specific version is that we can handle the
* details of the actual CSS rules, which can be complicated, especially
* for fonts
*/
gboolean st_theme_node_get_color (StThemeNode *node,
const char *property_name,
gboolean inherit,
ClutterColor *color);
gboolean st_theme_node_get_double (StThemeNode *node,
const char *property_name,
gboolean inherit,
double *value);
gboolean st_theme_node_get_length (StThemeNode *node,
const char *property_name,
gboolean inherit,
gdouble *length);
/* Specific getters for particular properties: cached
*/
void st_theme_node_get_background_color (StThemeNode *node,
ClutterColor *color);
void st_theme_node_get_foreground_color (StThemeNode *node,
ClutterColor *color);
const char *st_theme_node_get_background_image (StThemeNode *node);
double st_theme_node_get_border_width (StThemeNode *node,
StSide side);
void st_theme_node_get_border_color (StThemeNode *node,
StSide side,
ClutterColor *color);
double st_theme_node_get_padding (StThemeNode *node,
StSide side);
StTextDecoration st_theme_node_get_text_decoration (StThemeNode *node);
/* Font rule processing is pretty complicated, so we just hardcode it
* under the standard font/font-family/font-size/etc names. This means
* you can't have multiple separate styled fonts for a single item,
* but that should be OK.
*/
const PangoFontDescription *st_theme_node_get_font (StThemeNode *node);
/* This is the getter for -st-background-image, which is different from
* background-image in having provisions for unscaled borders.
*/
StThemeImage *st_theme_node_get_background_theme_image (StThemeNode *node);
G_END_DECLS
#endif /* __ST_THEME_NODE_H__ */
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#ifndef __ST_THEME_PRIVATE_H__
#define __ST_THEME_PRIVATE_H__
#include <libcroco/libcroco.h>
#include "st-theme.h"
G_BEGIN_DECLS
void _st_theme_get_matched_properties (StTheme *theme,
StThemeNode *node,
CRDeclaration ***properties,
int *n_properties);
/* Resolve an URL from the stylesheet to a filename */
char *_st_theme_resolve_url (StTheme *theme,
CRStyleSheet *base_stylesheet,
const char *url);
G_END_DECLS
#endif /* __ST_THEME_PRIVATE_H__ */
This diff is collapsed.
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#ifndef __ST_THEME_H__
#define __ST_THEME_H__
#include <glib-object.h>
#include "st-theme-node.h"
G_BEGIN_DECLS
/**
* SECTION:StTheme
* @short_description: a set of stylesheets
*
* #StTheme holds a set of stylesheets. (The "cascade" of the name
* Cascading Stylesheets.) A #StTheme can be set to apply to all the actors
* in a stage using st_theme_context_set_theme() or applied to a subtree
* of actors using st_widget_set_theme().
*/
typedef struct _StThemeClass StThemeClass;
#define ST_TYPE_THEME (st_theme_get_type ())
#define ST_THEME(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME, StTheme))
#define ST_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME, StThemeClass))
#define ST_IS_THEME(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME))
#define ST_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME))
#define ST_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME, StThemeClass))
GType st_theme_get_type (void) G_GNUC_CONST;
StTheme *st_theme_new (const char *application_stylesheet,
const char *theme_stylesheet,
const char *default_stylesheet);
G_END_DECLS