<STRUCT>
<NAME>RsvgBpathDef</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgBpathDef</NAME>
struct RsvgBpathDef {
	ArtBpath *bpath;
	int n_bpath;
	int n_bpath_max;
	int moveto_idx;
};
</STRUCT>
<FUNCTION>
<NAME>rsvg_bpath_def_new</NAME>
<RETURNS>RsvgBpathDef  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_new_from</NAME>
<RETURNS>RsvgBpathDef  *</RETURNS>
ArtBpath *bpath
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_free</NAME>
<RETURNS>void  </RETURNS>
RsvgBpathDef *bpd
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_moveto</NAME>
<RETURNS>void  </RETURNS>
RsvgBpathDef *bpd,double x, double y
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_lineto</NAME>
<RETURNS>void  </RETURNS>
RsvgBpathDef *bpd,double x, double y
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_curveto</NAME>
<RETURNS>void  </RETURNS>
RsvgBpathDef *bpd,double x1, double y1,double x2, double y2,double x3, double y3
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_closepath</NAME>
<RETURNS>void  </RETURNS>
RsvgBpathDef *bpd
</FUNCTION>
<FUNCTION>
<NAME>rsvg_bpath_def_art_finish</NAME>
<RETURNS>void  </RETURNS>
RsvgBpathDef *bpd
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_length</NAME>
<RETURNS>double</RETURNS>
const char *str, gdouble pixels_per_inch,gint *percent, gint *em, gint *ex
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_normalized_length</NAME>
<RETURNS>double</RETURNS>
const char *str, gdouble pixels_per_inch,gdouble width_or_height, gdouble font_size
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_param_match</NAME>
<RETURNS>gboolean</RETURNS>
const char *str, const char *param_name
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_param_arg_offset</NAME>
<RETURNS>int</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_color</NAME>
<RETURNS>guint32</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_opacity</NAME>
<RETURNS>guint</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_angle</NAME>
<RETURNS>double</RETURNS>
const char * str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_frequency</NAME>
<RETURNS>double</RETURNS>
const char * str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_time</NAME>
<RETURNS>double</RETURNS>
const char * str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_font_style</NAME>
<RETURNS>PangoStyle</RETURNS>
const char * str, PangoStyle inherit
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_font_variant</NAME>
<RETURNS>PangoVariant</RETURNS>
const char * str, PangoVariant inherit
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_font_weight</NAME>
<RETURNS>PangoWeight</RETURNS>
const char * str, PangoWeight inherit
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_font_stretch</NAME>
<RETURNS>PangoStretch</RETURNS>
const char * str, PangoStretch inherit
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_font_family</NAME>
<RETURNS>const char  *</RETURNS>
const char * str, const char * inherit
</FUNCTION>
<FUNCTION>
<NAME>rsvg_css_parse_vbox</NAME>
<RETURNS>gboolean</RETURNS>
const char * vbox, double * x, double * y,double * w, double * h
</FUNCTION>
<STRUCT>
<NAME>RsvgDefs</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgDefVal</NAME>
</STRUCT>
<ENUM>
<NAME>RsvgDefType</NAME>
typedef enum {
	/* todo: general question: should this be high level, ie a generic
	   paint server, coupled with a paint server interface; or low level,
	   ie specific definable things? For now, we're going low level,
	   but it's not clear that's the best way to go. */
	RSVG_DEF_LINGRAD,
	RSVG_DEF_RADGRAD,
	RSVG_DEF_PATTERN,
	RSVG_DEF_PATH
} RsvgDefType;
</ENUM>
<STRUCT>
<NAME>RsvgDefVal</NAME>
struct RsvgDefVal {
	RsvgDefType type;
	void (*free) (RsvgDefVal *self);
};
</STRUCT>
<FUNCTION>
<NAME>rsvg_defs_new</NAME>
<RETURNS>RsvgDefs  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>rsvg_defs_lookup</NAME>
<RETURNS>RsvgDefVal  *</RETURNS>
const RsvgDefs *defs, const char *name
</FUNCTION>
<FUNCTION>
<NAME>rsvg_defs_set</NAME>
<RETURNS>void</RETURNS>
RsvgDefs *defs, const char *name, RsvgDefVal *val
</FUNCTION>
<FUNCTION>
<NAME>rsvg_defs_free</NAME>
<RETURNS>void</RETURNS>
RsvgDefs *defs
</FUNCTION>
<STRUCT>
<NAME>RsvgGradientStop</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgGradientStops</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgLinearGradient</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgRadialGradient</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgPaintServer</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgPSCtx</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgPSCtx</NAME>
struct RsvgPSCtx {
	int dummy;
	/* todo: we need to take in some context information, including:
	   
	1. The global affine transformation.
	
	2. User coordinates at time of reference (to implement
	gradientUnits = "userSpaceOnUse").
	
	3. Object bounding box (to implement gradientUnits =
	"objectBoundingBox").
	
	Maybe signal for lazy evaluation of object bbox.
	*/
};
</STRUCT>
<STRUCT>
<NAME>RsvgGradientStop</NAME>
struct RsvgGradientStop {
	double offset;
	guint32 rgba;
};
</STRUCT>
<STRUCT>
<NAME>RsvgGradientStops</NAME>
struct RsvgGradientStops {
	int n_stop;
	RsvgGradientStop *stop;
};
</STRUCT>
<STRUCT>
<NAME>RsvgLinearGradient</NAME>
struct RsvgLinearGradient {
	RsvgDefVal super;
	gboolean obj_bbox;
	double affine[6]; /* user space to actual at time of gradient def */
	RsvgGradientStops *stops;
	ArtGradientSpread spread;
	double x1, y1;
	double x2, y2;
};
</STRUCT>
<STRUCT>
<NAME>RsvgRadialGradient</NAME>
struct RsvgRadialGradient {
	RsvgDefVal super;
	gboolean obj_bbox;
	double affine[6]; /* user space to actual at time of gradient def */
	RsvgGradientStops *stops;
	ArtGradientSpread spread;
	double cx, cy;
	double r;
	double fx, fy;
};
</STRUCT>
<FUNCTION>
<NAME>rsvg_paint_server_parse</NAME>
<RETURNS>RsvgPaintServer  *</RETURNS>
const RsvgDefs *defs, const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_render_paint_server</NAME>
<RETURNS>void</RETURNS>
ArtRender *ar, RsvgPaintServer *ps,const RsvgPSCtx *ctx
</FUNCTION>
<FUNCTION>
<NAME>rsvg_paint_server_ref</NAME>
<RETURNS>void</RETURNS>
RsvgPaintServer *ps
</FUNCTION>
<FUNCTION>
<NAME>rsvg_paint_server_unref</NAME>
<RETURNS>void</RETURNS>
RsvgPaintServer *ps
</FUNCTION>
<FUNCTION>
<NAME>rsvg_clone_radial_gradient</NAME>
<RETURNS>RsvgRadialGradient  *</RETURNS>
const RsvgRadialGradient *grad, gboolean * shallow_cloned
</FUNCTION>
<FUNCTION>
<NAME>rsvg_clone_linear_gradient</NAME>
<RETURNS>RsvgLinearGradient  *</RETURNS>
const RsvgLinearGradient *grad, gboolean * shallow_cloned
</FUNCTION>
<FUNCTION>
<NAME>rsvg_parse_path</NAME>
<RETURNS>RsvgBpathDef  *</RETURNS>
const char *path_str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_linear_gradient_free</NAME>
<RETURNS>void  </RETURNS>
RsvgDefVal *self
</FUNCTION>
<FUNCTION>
<NAME>rsvg_radial_gradient_free</NAME>
<RETURNS>void  </RETURNS>
RsvgDefVal *self
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_init</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle * handle
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_write_impl</NAME>
<RETURNS>gboolean  </RETURNS>
RsvgHandle    *handle,const guchar  *buf,gsize          count,GError       **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_close_impl</NAME>
<RETURNS>gboolean  </RETURNS>
RsvgHandle  *handle,GError     **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_free_impl</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>rsvg_render_path</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const char *d
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_path</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_polygon</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_polyline</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_line</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_rect</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_circle</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_ellipse</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_image</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_use</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<TYPEDEF>
<NAME>TextDecoration</NAME>
typedef int TextDecoration;
</TYPEDEF>
<TYPEDEF>
<NAME>RsvgState</NAME>
typedef struct {
	double affine[6];
	
	gint opacity; /* 0..255 */
	
	RsvgPaintServer *fill;
	gint fill_opacity; /* 0..255 */
	
	RsvgPaintServer *stroke;
	gint stroke_opacity; /* 0..255 */
	double stroke_width;
	double miter_limit;
	
	ArtPathStrokeCapType cap;
	ArtPathStrokeJoinType join;
	
	double         font_size;
	char        *  font_family;
	PangoStyle     font_style;
	PangoVariant   font_variant;
	PangoWeight    font_weight;
	PangoStretch   font_stretch;
	TextDecoration font_decor;
	PangoDirection text_dir;	

	guint text_offset;
	
	guint32 stop_color; /* rgb */
	gint stop_opacity;  /* 0..255 */
	
	gboolean visible;

	ArtVpathDash dash;
	
	GdkPixbuf *save_pixbuf;
} RsvgState;
</TYPEDEF>
<FUNCTION>
<NAME>rsvg_state_init</NAME>
<RETURNS>void  </RETURNS>
RsvgState *state
</FUNCTION>
<FUNCTION>
<NAME>rsvg_state_clone</NAME>
<RETURNS>void  </RETURNS>
RsvgState *dst, const RsvgState *src
</FUNCTION>
<FUNCTION>
<NAME>rsvg_state_finalize</NAME>
<RETURNS>void  </RETURNS>
RsvgState *state
</FUNCTION>
<FUNCTION>
<NAME>rsvg_is_style_arg</NAME>
<RETURNS>gboolean  </RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_parse_style_pair</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, RsvgState *state,const char *key, const char *val
</FUNCTION>
<FUNCTION>
<NAME>rsvg_parse_style</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, RsvgState *state, const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_parse_cssbuffer</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const char * buff, size_t buflen
</FUNCTION>
<FUNCTION>
<NAME>rsvg_parse_style_attrs</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, RsvgState *state, const char * tag,const char * klazz, const char * id,const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_viewport_percentage</NAME>
<RETURNS>gdouble  </RETURNS>
gdouble width, gdouble height
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pop_opacity_group</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, int opacity
</FUNCTION>
<FUNCTION>
<NAME>rsvg_push_opacity_group</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx
</FUNCTION>
<FUNCTION>
<NAME>rsvg_parse_transform</NAME>
<RETURNS>gboolean  </RETURNS>
double dst[6], const char *src
</FUNCTION>
<FUNCTION>
<NAME>rsvg_state_current</NAME>
<RETURNS>RsvgState  *</RETURNS>
RsvgHandle *ctx
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_text</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>rsvg_start_tspan</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle *ctx, const xmlChar **atts
</FUNCTION>
<FUNCTION>
<NAME>make_valid_utf8</NAME>
<RETURNS>char  *</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_new_gz</NAME>
<RETURNS>RsvgHandle  *</RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>RsvgError</NAME>
typedef enum {
	RSVG_ERROR_FAILED
} RsvgError;
</ENUM>
<MACRO>
<NAME>RSVG_ERROR</NAME>
#define RSVG_ERROR (rsvg_error_quark ())
</MACRO>
<FUNCTION>
<NAME>rsvg_error_quark</NAME>
<RETURNS>GQuark  </RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>RsvgSizeFunc</NAME>
<RETURNS>void </RETURNS>
gint     *width,
							   gint     *height,
							   gpointer  user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>rsvg_set_default_dpi</NAME>
<RETURNS>void  </RETURNS>
double dpi
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_new</NAME>
<RETURNS>RsvgHandle  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_set_dpi</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle * handle, double dpi
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_set_size_callback</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle      *handle,RsvgSizeFunc     size_func,gpointer         user_data,GDestroyNotify   user_data_destroy
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_write</NAME>
<RETURNS>gboolean  </RETURNS>
RsvgHandle      *handle,const guchar    *buf,gsize            count,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_close</NAME>
<RETURNS>gboolean  </RETURNS>
RsvgHandle      *handle,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_get_pixbuf</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
RsvgHandle      *handle
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_free</NAME>
<RETURNS>void  </RETURNS>
RsvgHandle      *handle
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
const gchar  *file_name,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_zoom</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
const gchar  *file_name,double        x_zoom,double        y_zoom,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_size</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
const gchar  *file_name,gint          width,gint          height,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_max_size</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
const gchar  *file_name,gint          max_width,gint          max_height,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_zoom_with_max</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
const gchar  *file_name,double        x_zoom,double        y_zoom,gint          max_width,gint          max_height,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_get_title</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
RsvgHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>rsvg_handle_get_desc</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
RsvgHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_size_ex</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
RsvgHandle * handle,const gchar  *file_name,gint          width,gint          height,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_ex</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
RsvgHandle * handle,const gchar  *file_name,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_zoom_ex</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
RsvgHandle * handle,const gchar  *file_name,double        x_zoom,double        y_zoom,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_max_size_ex</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
RsvgHandle * handle,const gchar  *file_name,gint          max_width,gint          max_height,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>rsvg_pixbuf_from_file_at_zoom_with_max_ex</NAME>
<RETURNS>GdkPixbuf   *</RETURNS>
RsvgHandle * handle,const gchar  *file_name,double        x_zoom,double        y_zoom,gint          max_width,gint          max_height,GError      **error
</FUNCTION>
<MACRO>
<NAME>LIBRSVG_MAJOR_VERSION</NAME>
#define LIBRSVG_MAJOR_VERSION (2)
</MACRO>
<MACRO>
<NAME>LIBRSVG_MINOR_VERSION</NAME>
#define LIBRSVG_MINOR_VERSION (4)
</MACRO>
<MACRO>
<NAME>LIBRSVG_MICRO_VERSION</NAME>
#define LIBRSVG_MICRO_VERSION (0)
</MACRO>
<MACRO>
<NAME>LIBRSVG_VERSION</NAME>
#define LIBRSVG_VERSION ""
</MACRO>
<VARIABLE>
<NAME>librsvg_version</NAME>
extern const char *librsvg_version;
</VARIABLE>
<FUNCTION>
<NAME>librsvg_preinit</NAME>
<RETURNS>void  </RETURNS>
void *app, void *modinfo
</FUNCTION>
<FUNCTION>
<NAME>librsvg_postinit</NAME>
<RETURNS>void  </RETURNS>
void *app, void *modinfo
</FUNCTION>
<MACRO>
<NAME>HAVE_DLFCN_H</NAME>
#define HAVE_DLFCN_H 1
</MACRO>
<MACRO>
<NAME>HAVE_INTTYPES_H</NAME>
#define HAVE_INTTYPES_H 1
</MACRO>
<MACRO>
<NAME>HAVE_MEMORY_H</NAME>
#define HAVE_MEMORY_H 1
</MACRO>
<MACRO>
<NAME>HAVE_STDINT_H</NAME>
#define HAVE_STDINT_H 1
</MACRO>
<MACRO>
<NAME>HAVE_STDLIB_H</NAME>
#define HAVE_STDLIB_H 1
</MACRO>
<MACRO>
<NAME>HAVE_STRINGS_H</NAME>
#define HAVE_STRINGS_H 1
</MACRO>
<MACRO>
<NAME>HAVE_STRING_H</NAME>
#define HAVE_STRING_H 1
</MACRO>
<MACRO>
<NAME>HAVE_SYS_STAT_H</NAME>
#define HAVE_SYS_STAT_H 1
</MACRO>
<MACRO>
<NAME>HAVE_SYS_TYPES_H</NAME>
#define HAVE_SYS_TYPES_H 1
</MACRO>
<MACRO>
<NAME>HAVE_UNISTD_H</NAME>
#define HAVE_UNISTD_H 1
</MACRO>
<MACRO>
<NAME>PACKAGE</NAME>
#define PACKAGE "librsvg"
</MACRO>
<MACRO>
<NAME>PACKAGE_BUGREPORT</NAME>
#define PACKAGE_BUGREPORT ""
</MACRO>
<MACRO>
<NAME>PACKAGE_NAME</NAME>
#define PACKAGE_NAME ""
</MACRO>
<MACRO>
<NAME>PACKAGE_STRING</NAME>
#define PACKAGE_STRING ""
</MACRO>
<MACRO>
<NAME>PACKAGE_TARNAME</NAME>
#define PACKAGE_TARNAME ""
</MACRO>
<MACRO>
<NAME>PACKAGE_VERSION</NAME>
#define PACKAGE_VERSION ""
</MACRO>
<MACRO>
<NAME>STDC_HEADERS</NAME>
#define STDC_HEADERS 1
</MACRO>
<MACRO>
<NAME>VERSION</NAME>
#define VERSION "2.4.0"
</MACRO>
<STRUCT>
<NAME>RsvgRcStyle</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgRcStyleClass</NAME>
</STRUCT>
<VARIABLE>
<NAME>rsvg_type_rc_style</NAME>
extern GType rsvg_type_rc_style;
</VARIABLE>
<MACRO>
<NAME>RSVG_TYPE_RC_STYLE</NAME>
#define RSVG_TYPE_RC_STYLE              rsvg_type_rc_style
</MACRO>
<MACRO>
<NAME>RSVG_RC_STYLE</NAME>
#define RSVG_RC_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), RSVG_TYPE_RC_STYLE, RsvgRcStyle))
</MACRO>
<MACRO>
<NAME>RSVG_RC_STYLE_CLASS</NAME>
#define RSVG_RC_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), RSVG_TYPE_RC_STYLE, RsvgRcStyleClass))
</MACRO>
<MACRO>
<NAME>RSVG_IS_RC_STYLE</NAME>
#define RSVG_IS_RC_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), RSVG_TYPE_RC_STYLE))
</MACRO>
<MACRO>
<NAME>RSVG_IS_RC_STYLE_CLASS</NAME>
#define RSVG_IS_RC_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), RSVG_TYPE_RC_STYLE))
</MACRO>
<MACRO>
<NAME>RSVG_RC_STYLE_GET_CLASS</NAME>
#define RSVG_RC_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), RSVG_TYPE_RC_STYLE, RsvgRcStyleClass))
</MACRO>
<STRUCT>
<NAME>RsvgRcStyle</NAME>
struct RsvgRcStyle
{
  GtkRcStyle parent_instance;
  
  GList *img_list;
};
</STRUCT>
<STRUCT>
<NAME>RsvgRcStyleClass</NAME>
struct RsvgRcStyleClass
{
  GtkRcStyleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>rsvg_rc_style_register_type</NAME>
<RETURNS>void  </RETURNS>
GTypeModule *module
</FUNCTION>
<STRUCT>
<NAME>RsvgStyle</NAME>
</STRUCT>
<STRUCT>
<NAME>RsvgStyleClass</NAME>
</STRUCT>
<VARIABLE>
<NAME>rsvg_type_style</NAME>
extern GType rsvg_type_style;
</VARIABLE>
<MACRO>
<NAME>RSVG_TYPE_STYLE</NAME>
#define RSVG_TYPE_STYLE              rsvg_type_style
</MACRO>
<MACRO>
<NAME>RSVG_STYLE</NAME>
#define RSVG_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), RSVG_TYPE_STYLE, RsvgStyle))
</MACRO>
<MACRO>
<NAME>RSVG_STYLE_CLASS</NAME>
#define RSVG_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), RSVG_TYPE_STYLE, RsvgStyleClass))
</MACRO>
<MACRO>
<NAME>RSVG_IS_STYLE</NAME>
#define RSVG_IS_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), RSVG_TYPE_STYLE))
</MACRO>
<MACRO>
<NAME>RSVG_IS_STYLE_CLASS</NAME>
#define RSVG_IS_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), RSVG_TYPE_STYLE))
</MACRO>
<MACRO>
<NAME>RSVG_STYLE_GET_CLASS</NAME>
#define RSVG_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), RSVG_TYPE_STYLE, RsvgStyleClass))
</MACRO>
<STRUCT>
<NAME>RsvgStyle</NAME>
struct RsvgStyle
{
  GtkStyle parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>RsvgStyleClass</NAME>
struct RsvgStyleClass
{
  GtkStyleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>rsvg_style_register_type</NAME>
<RETURNS>void  </RETURNS>
GTypeModule *module
</FUNCTION>
<STRUCT>
<NAME>ThemeData</NAME>
</STRUCT>
<STRUCT>
<NAME>ThemeImage</NAME>
</STRUCT>
<STRUCT>
<NAME>ThemeMatchData</NAME>
</STRUCT>
<STRUCT>
<NAME>ThemePixbuf</NAME>
</STRUCT>
<ENUM>
<NAME>ThemePixbufComponent</NAME>
typedef enum
{
  COMPONENT_NORTH_WEST = 1 << 0,
  COMPONENT_NORTH      = 1 << 1,
  COMPONENT_NORTH_EAST = 1 << 2, 
  COMPONENT_WEST       = 1 << 3,
  COMPONENT_CENTER     = 1 << 4,
  COMPONENT_EAST       = 1 << 5, 
  COMPONENT_SOUTH_EAST = 1 << 6,
  COMPONENT_SOUTH      = 1 << 7,
  COMPONENT_SOUTH_WEST = 1 << 8,
  COMPONENT_ALL 	  = 1 << 9
} ThemePixbufComponent;
</ENUM>
<ENUM>
<NAME>ThemeMatchFlags</NAME>
typedef enum {
  THEME_MATCH_GAP_SIDE        = 1 << 0,
  THEME_MATCH_ORIENTATION     = 1 << 1,
  THEME_MATCH_STATE           = 1 << 2,
  THEME_MATCH_SHADOW          = 1 << 3,
  THEME_MATCH_ARROW_DIRECTION = 1 << 4
} ThemeMatchFlags;
</ENUM>
<ENUM>
<NAME>ThemeRenderHints</NAME>
typedef enum {
  THEME_CONSTANT_ROWS = 1 << 0,
  THEME_CONSTANT_COLS = 1 << 1,
  THEME_MISSING = 1 << 2
} ThemeRenderHints;
</ENUM>
<STRUCT>
<NAME>ThemePixbuf</NAME>
struct ThemePixbuf
{
  gchar     *filename;
  GdkPixbuf *pixbuf;
  gboolean   stretch;
  gint       border_left;
  gint       border_right;
  gint       border_bottom;
  gint       border_top;
  guint      hints[3][3];
};
</STRUCT>
<STRUCT>
<NAME>ThemeMatchData</NAME>
struct ThemeMatchData
{
  guint           function;	/* Mandatory */
  gchar          *detail;

  ThemeMatchFlags flags;

  GtkPositionType gap_side;
  GtkOrientation  orientation;
  GtkStateType    state;
  GtkShadowType   shadow;
  GtkArrowType    arrow_direction;
};
</STRUCT>
<STRUCT>
<NAME>ThemeImage</NAME>
struct ThemeImage
{
  guint           refcount;

  ThemePixbuf    *background;
  ThemePixbuf    *overlay;
  ThemePixbuf    *gap_start;
  ThemePixbuf    *gap;
  ThemePixbuf    *gap_end;
  
  gchar           recolorable;

  ThemeMatchData  match_data;
};
</STRUCT>
<FUNCTION>
<NAME>theme_pixbuf_new</NAME>
<RETURNS>ThemePixbuf  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>theme_pixbuf_destroy</NAME>
<RETURNS>void  </RETURNS>
ThemePixbuf  *theme_pb
</FUNCTION>
<FUNCTION>
<NAME>theme_pixbuf_set_filename</NAME>
<RETURNS>void  </RETURNS>
ThemePixbuf  *theme_pb,const char   *filename
</FUNCTION>
<FUNCTION>
<NAME>theme_pixbuf_get_pixbuf</NAME>
<RETURNS>GdkPixbuf  *</RETURNS>
ThemePixbuf  *theme_pb
</FUNCTION>
<FUNCTION>
<NAME>theme_pixbuf_set_border</NAME>
<RETURNS>void  </RETURNS>
ThemePixbuf  *theme_pb,gint          left,gint          right,gint          top,gint          bottom
</FUNCTION>
<FUNCTION>
<NAME>theme_pixbuf_set_stretch</NAME>
<RETURNS>void  </RETURNS>
ThemePixbuf  *theme_pb,gboolean      stretch
</FUNCTION>
<FUNCTION>
<NAME>theme_pixbuf_render</NAME>
<RETURNS>void  </RETURNS>
ThemePixbuf  *theme_pb,GdkWindow    *window,GdkBitmap    *mask,GdkRectangle *clip_rect,guint         component_mask,gboolean      center,gint          dest_x,gint          dest_y,gint          dest_width,gint          dest_height
</FUNCTION>
