<FUNCTION>
<NAME>libgoffice_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>libgoffice_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GO_VAR_DECL</NAME>
#      define GO_VAR_DECL __declspec(dllexport)
</MACRO>
<MACRO>
<NAME>GO_VAR_DECL</NAME>
#      define GO_VAR_DECL extern __declspec(dllimport)
</MACRO>
<MACRO>
<NAME>GO_VAR_DECL</NAME>
#    define GO_VAR_DECL extern
</MACRO>
<FUNCTION>
<NAME>go_range_sum</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_sumsq</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_average</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_min</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_max</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_maxabs</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_devsq</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_fractile_inter</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res, double f
</FUNCTION>
<FUNCTION>
<NAME>go_range_fractile_inter_nonconst</NAME>
<RETURNS>int </RETURNS>
double *xs, int n, double *res, double f
</FUNCTION>
<FUNCTION>
<NAME>go_range_fractile_inter_sorted</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res, double f
</FUNCTION>
<FUNCTION>
<NAME>go_range_median_inter</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_median_inter_nonconst</NAME>
<RETURNS>int </RETURNS>
double *xs, int n, double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_increasing</NAME>
<RETURNS>int </RETURNS>
double const *xs, int n
</FUNCTION>
<FUNCTION>
<NAME>go_range_suml</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_sumsql</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_averagel</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_minl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_maxl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_maxabsl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_devsql</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_fractile_interl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res, long double f
</FUNCTION>
<FUNCTION>
<NAME>go_range_fractile_inter_nonconstl</NAME>
<RETURNS>int </RETURNS>
long double *xs, int n, long double *res, long double f
</FUNCTION>
<FUNCTION>
<NAME>go_range_fractile_inter_sortedl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res, long double f
</FUNCTION>
<FUNCTION>
<NAME>go_range_median_interl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_median_inter_nonconstl</NAME>
<RETURNS>int </RETURNS>
long double *xs, int n, long double *res
</FUNCTION>
<FUNCTION>
<NAME>go_range_increasingl</NAME>
<RETURNS>int </RETURNS>
long double const *xs, int n
</FUNCTION>
<STRUCT>
<NAME>go_complex</NAME>
typedef struct {
	double re, im;
} go_complex;
</STRUCT>
<STRUCT>
<NAME>go_complexl</NAME>
typedef struct {
	long double re, im;
} go_complexl;
</STRUCT>
<FUNCTION>
<NAME>go_complex_to_string</NAME>
<RETURNS>char *</RETURNS>
go_complex const *src, char const *reformat,char const *imformat, char imunit
</FUNCTION>
<FUNCTION>
<NAME>go_complex_from_string</NAME>
<RETURNS>int </RETURNS>
go_complex *dst, char const *src, char *imunit
</FUNCTION>
<FUNCTION>
<NAME>go_complex_to_polar</NAME>
<RETURNS>void </RETURNS>
double *mod, double *angle, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_from_polar</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, double mod, double angle
</FUNCTION>
<FUNCTION>
<NAME>go_complex_mul</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *a, go_complex const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_div</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *a, go_complex const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_pow</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *a, go_complex const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_sqrt</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_init</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, double re, double im
</FUNCTION>
<FUNCTION>
<NAME>go_complex_real</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, double re
</FUNCTION>
<FUNCTION>
<NAME>go_complex_real_p</NAME>
<RETURNS>int </RETURNS>
go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_zero_p</NAME>
<RETURNS>int </RETURNS>
go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_mod</NAME>
<RETURNS>double </RETURNS>
go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_angle</NAME>
<RETURNS>double </RETURNS>
go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_conj</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_scale_real</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, double f
</FUNCTION>
<FUNCTION>
<NAME>go_complex_add</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *a, go_complex const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_sub</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *a, go_complex const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_exp</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_ln</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_sin</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_cos</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_tan</NAME>
<RETURNS>void </RETURNS>
go_complex *dst, go_complex const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_to_stringl</NAME>
<RETURNS>char *</RETURNS>
go_complexl const *src, char const *reformat,char const *imformat, char imunit
</FUNCTION>
<FUNCTION>
<NAME>go_complex_from_stringl</NAME>
<RETURNS>int </RETURNS>
go_complexl *dst, char const *src, char *imunit
</FUNCTION>
<FUNCTION>
<NAME>go_complex_to_polarl</NAME>
<RETURNS>void </RETURNS>
long double *mod, long double *angle, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_from_polarl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, long double mod, long double angle
</FUNCTION>
<FUNCTION>
<NAME>go_complex_mull</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *a, go_complexl const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_divl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *a, go_complexl const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_powl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *a, go_complexl const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_sqrtl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_initl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, long double re, long double im
</FUNCTION>
<FUNCTION>
<NAME>go_complex_reall</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, long double re
</FUNCTION>
<FUNCTION>
<NAME>go_complex_real_pl</NAME>
<RETURNS>int </RETURNS>
go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_zero_pl</NAME>
<RETURNS>int </RETURNS>
go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_conjl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_scale_reall</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, long double f
</FUNCTION>
<FUNCTION>
<NAME>go_complex_addl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *a, go_complexl const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_subl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *a, go_complexl const *b
</FUNCTION>
<FUNCTION>
<NAME>go_complex_expl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_lnl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_sinl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_cosl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<FUNCTION>
<NAME>go_complex_tanl</NAME>
<RETURNS>void </RETURNS>
go_complexl *dst, go_complexl const *src
</FUNCTION>
<STRUCT>
<NAME>GOCSpline</NAME>
struct GOCSpline {
	double const *x, *y;
	double *a, *b, *c;
	int n;
};
</STRUCT>
<ENUM>
<NAME>GOCSplineType</NAME>
typedef enum {
	GO_CSPLINE_NATURAL,
	GO_CSPLINE_PARABOLIC,
	GO_CSPLINE_CUBIC,
	GO_CSPLINE_CLAMPED,
	GO_CSPLINE_MAX,
} GOCSplineType;
</ENUM>
<STRUCT>
<NAME>GOCSpline</NAME>
struct GOCSpline *go_cspline_init (double const *x, double const *y, int n,
				   unsigned limits, double c0, double cn);
void go_cspline_destroy (struct GOCSpline *sp);
double go_cspline_get_value (struct GOCSpline *sp, double x);
double go_cspline_get_deriv (struct GOCSpline *sp, double x);
double *go_cspline_get_values (struct GOCSpline *sp, double const *x, int n);
double *go_cspline_get_derivs (struct GOCSpline *sp, double const *x, int n);
double *go_cspline_get_integrals (struct GOCSpline *sp, double const *x, int n);

#ifdef GOFFICE_WITH_LONG_DOUBLE
struct GOCSplinel {
	long double const *x, *y;
	long double *a, *b, *c;
	int n;
};
</STRUCT>
<MACRO>
<NAME>M_PI</NAME>
#define M_PI 3.14159265358979323846
</MACRO>
<FUNCTION>
<NAME>go_math_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_continued_fraction</NAME>
<RETURNS>void </RETURNS>
double val, int max_denom, int *res_num, int *res_denom
</FUNCTION>
<FUNCTION>
<NAME>go_stern_brocot</NAME>
<RETURNS>void </RETURNS>
double val, int max_denom, int *res_num, int *res_denom
</FUNCTION>
<FUNCTION>
<NAME>go_add_epsilon</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_sub_epsilon</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_fake_floor</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_fake_ceil</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_fake_round</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_fake_trunc</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_rint</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_finite</NAME>
<RETURNS>int </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>go_pow2</NAME>
<RETURNS>double </RETURNS>
int n
</FUNCTION>
<FUNCTION>
<NAME>go_pow10</NAME>
<RETURNS>double </RETURNS>
int n
</FUNCTION>
<FUNCTION>
<NAME>go_strtod</NAME>
<RETURNS>double </RETURNS>
const char *s, char **end
</FUNCTION>
<FUNCTION>
<NAME>go_ascii_strtod</NAME>
<RETURNS>double </RETURNS>
const char *s, char **end
</FUNCTION>
<FUNCTION>
<NAME>asinh</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>acosh</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>atanh</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>log1p</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<FUNCTION>
<NAME>expm1</NAME>
<RETURNS>double </RETURNS>
double x
</FUNCTION>
<MACRO>
<NAME>go_finitel</NAME>
#define go_finitel finitel
</MACRO>
<MACRO>
<NAME>isnan</NAME>
#define isnan _isnan
</MACRO>
<MACRO>
<NAME>finite</NAME>
#define finite _finite
</MACRO>
<ENUM>
<NAME>RegressionResult</NAME>
typedef enum {
	REG_ok,
	REG_invalid_dimensions,
	REG_invalid_data,
	REG_not_enough_data,
	REG_near_singular_good,	/* Probably good result */
	REG_near_singular_bad, 	/* Probably bad result */
	REG_singular
} RegressionResult;
</ENUM>
<STRUCT>
<NAME>go_regression_stat_t</NAME>
typedef struct {
        double *se;		/* SE for each parameter estimator */
        double *t;  		/* t values for each parameter estimator */
        double sqr_r;
	double adj_sqr_r;
        double se_y; 		/* The Standard Error of Y */
        double F;
        int    df_reg;
        int    df_resid;
        int    df_total;
        double ss_reg;
        double ss_resid;
        double ss_total;
        double ms_reg;
        double ms_resid;
	double ybar;
	double *xbar;
	double var; 		/* The variance of the entire regression: sum(errors^2)/(n-xdim) */
} go_regression_stat_t;
</STRUCT>
<FUNCTION>
<NAME>go_regression_stat_new</NAME>
<RETURNS>go_regression_stat_t 	*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_regression_stat_destroy</NAME>
<RETURNS>void 			 </RETURNS>
go_regression_stat_t *regression_stat
</FUNCTION>
<FUNCTION>
<NAME>go_linear_regression</NAME>
<RETURNS>RegressionResult 	 </RETURNS>
double **xss, int dim,const double *ys, int n,gboolean affine,double *res,go_regression_stat_t *stat
</FUNCTION>
<FUNCTION>
<NAME>go_exponential_regression</NAME>
<RETURNS>RegressionResult 	 </RETURNS>
double **xss, int dim,const double *ys, int n,gboolean affine,double *res,go_regression_stat_t *stat
</FUNCTION>
<FUNCTION>
<NAME>go_power_regression</NAME>
<RETURNS>RegressionResult 	 </RETURNS>
double **xss, int dim,const double *ys, int n,gboolean affine,double *res,go_regression_stat_t *stat
</FUNCTION>
<FUNCTION>
<NAME>go_logarithmic_regression</NAME>
<RETURNS>RegressionResult 	 </RETURNS>
double **xss, int dim,const double *ys, int n,gboolean affine,double *res,go_regression_stat_t *stat
</FUNCTION>
<MACRO>
<NAME>LOGFIT_C_ACCURACY</NAME>
#define LOGFIT_C_ACCURACY 0.000001
</MACRO>
<MACRO>
<NAME>LOGFIT_C_STEP_FACTOR</NAME>
#define LOGFIT_C_STEP_FACTOR 0.05
</MACRO>
<MACRO>
<NAME>LOGFIT_C_RANGE_FACTOR</NAME>
#define LOGFIT_C_RANGE_FACTOR 100
</MACRO>
<FUNCTION>
<NAME>go_logarithmic_fit</NAME>
<RETURNS>RegressionResult </RETURNS>
double *xs,const double *ys, int n,double *res
</FUNCTION>
<USER_FUNCTION>
<NAME>GORegressionFunction</NAME>
<RETURNS>RegressionResult </RETURNS>
double * x, double * params, double *f
</USER_FUNCTION>
<FUNCTION>
<NAME>go_non_linear_regression</NAME>
<RETURNS>RegressionResult </RETURNS>
GORegressionFunction f,double **xvals,double *par,double *yvals,double *sigmas,int x_dim,int p_dim,double *chi,double *errors
</FUNCTION>
<FUNCTION>
<NAME>go_matrix_invert</NAME>
<RETURNS>gboolean </RETURNS>
double **A, int n
</FUNCTION>
<FUNCTION>
<NAME>go_matrix_determinant</NAME>
<RETURNS>double   </RETURNS>
double **A, int n
</FUNCTION>
<STRUCT>
<NAME>go_regression_stat_tl</NAME>
typedef struct {
        long double *se; /*SE for each parameter estimator*/
        long double *t;  /*t values for each parameter estimator*/
        long double sqr_r;
	long double adj_sqr_r;
        long double se_y; /* The Standard Error of Y */
        long double F;
        int        df_reg;
        int        df_resid;
        int        df_total;
        long double ss_reg;
        long double ss_resid;
        long double ss_total;
        long double ms_reg;
        long double ms_resid;
	long double ybar;
	long double *xbar;
	long double var; /* The variance of the entire regression:
			sum(errors^2)/(n-xdim) */
} go_regression_stat_tl;
</STRUCT>
<FUNCTION>
<NAME>go_regression_stat_newl</NAME>
<RETURNS>go_regression_stat_tl *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_regression_stat_destroyl</NAME>
<RETURNS>void 		    </RETURNS>
go_regression_stat_tl *regression_stat
</FUNCTION>
<FUNCTION>
<NAME>go_linear_regressionl</NAME>
<RETURNS>RegressionResult    </RETURNS>
long double **xss, int dim,const long double *ys, int n,gboolean affine,long double *res,go_regression_stat_tl *stat
</FUNCTION>
<FUNCTION>
<NAME>go_exponential_regressionl</NAME>
<RETURNS>RegressionResult    </RETURNS>
long double **xss, int dim,const long double *ys, int n,gboolean affine,long double *res,go_regression_stat_tl *stat
</FUNCTION>
<FUNCTION>
<NAME>go_power_regressionl</NAME>
<RETURNS>RegressionResult    </RETURNS>
long double **xss, int dim,const long double *ys, int n,gboolean affine,long double *res,go_regression_stat_tl *stat
</FUNCTION>
<FUNCTION>
<NAME>go_logarithmic_regressionl</NAME>
<RETURNS>RegressionResult    </RETURNS>
long double **xss, int dim,const long double *ys, int n,gboolean affine,long double *res,go_regression_stat_tl *stat
</FUNCTION>
<FUNCTION>
<NAME>go_logarithmic_fitl</NAME>
<RETURNS>RegressionResult    </RETURNS>
long double *xs,const long double *ys, int n,long double *res
</FUNCTION>
<USER_FUNCTION>
<NAME>GORegressionFunctionl</NAME>
<RETURNS>RegressionResult </RETURNS>
long double * x, long double * params, long double *f
</USER_FUNCTION>
<FUNCTION>
<NAME>go_non_linear_regressionl</NAME>
<RETURNS>RegressionResult    </RETURNS>
GORegressionFunctionl f,long double **xvals,long double *par,long double *yvals,long double *sigmas,int x_dim,int p_dim,long double *chi,long double *errors
</FUNCTION>
<FUNCTION>
<NAME>go_matrix_invertl</NAME>
<RETURNS>gboolean    </RETURNS>
long double **A, int n
</FUNCTION>
<FUNCTION>
<NAME>go_fourier_fft</NAME>
<RETURNS>void </RETURNS>
go_complex const *in, int n, int skip, go_complex **fourier, gboolean inverse
</FUNCTION>
<FUNCTION>
<NAME>go_fourier_fftl</NAME>
<RETURNS>void </RETURNS>
go_complexl const *in, int n, int skip, go_complexl **fourier, gboolean inverse
</FUNCTION>
<MACRO>
<NAME>GO_FONT_SEL_TYPE</NAME>
#define GO_FONT_SEL_TYPE	(go_font_sel_get_type ())
</MACRO>
<MACRO>
<NAME>GO_FONT_SEL</NAME>
#define GO_FONT_SEL(obj)	(G_TYPE_CHECK_INSTANCE_CAST((obj), GO_FONT_SEL_TYPE, GOFontSel))
</MACRO>
<MACRO>
<NAME>IS_GO_FONT_SEL</NAME>
#define IS_GO_FONT_SEL(obj)	(G_TYPE_CHECK_INSTANCE_TYPE((obj), GO_FONT_SEL_TYPE))
</MACRO>
<STRUCT>
<NAME>GOFontSel</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_font_sel_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_font_sel_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_font_sel_set_font</NAME>
<RETURNS>void	      </RETURNS>
GOFontSel *fs, GOFont const *font
</FUNCTION>
<FUNCTION>
<NAME>go_font_sel_get_font</NAME>
<RETURNS>GOFont const *</RETURNS>
GOFontSel const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_font_sel_editable_enters</NAME>
<RETURNS>void </RETURNS>
GOFontSel *fs, GtkWindow *dialog
</FUNCTION>
<FUNCTION>
<NAME>go_font_sel_set_sample_text</NAME>
<RETURNS>void </RETURNS>
GOFontSel *fs, char const *text
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_DOCK_ITEM</NAME>
#define GO_TYPE_DOCK_ITEM            (go_dock_item_get_type())
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM</NAME>
#define GO_DOCK_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_DOCK_ITEM, GoDockItem))
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM_CLASS</NAME>
#define GO_DOCK_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_DOCK_ITEM, GoDockItemClass))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_ITEM</NAME>
#define GO_IS_DOCK_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_DOCK_ITEM))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_ITEM_CLASS</NAME>
#define GO_IS_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_DOCK_ITEM))
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM_GET_CLASS</NAME>
#define GO_DOCK_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_DOCK_ITEM, GoDockItemClass))
</MACRO>
<ENUM>
<NAME>GoDockItemBehavior</NAME>
typedef enum
{
  GO_DOCK_ITEM_BEH_NORMAL = 0,
  GO_DOCK_ITEM_BEH_EXCLUSIVE = 1 << 0,
  GO_DOCK_ITEM_BEH_NEVER_FLOATING = 1 << 1,
  GO_DOCK_ITEM_BEH_NEVER_VERTICAL = 1 << 2,
  GO_DOCK_ITEM_BEH_NEVER_HORIZONTAL = 1 << 3,
  GO_DOCK_ITEM_BEH_LOCKED = 1 << 4
  /* MAINT: Update the size of the bit field in the GoDockItem structure if you add items to this */
} GoDockItemBehavior;
</ENUM>
<MACRO>
<NAME>GO_DOCK_ITEM_BEH_NEVER_DETACH</NAME>
#define GO_DOCK_ITEM_BEH_NEVER_DETACH GO_DOCK_ITEM_BEH_NEVER_FLOATING
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM_NOT_LOCKED</NAME>
#define GO_DOCK_ITEM_NOT_LOCKED(x) (! (GO_DOCK_ITEM(x)->behavior \
                                          & GO_DOCK_ITEM_BEH_LOCKED))
</MACRO>
<STRUCT>
<NAME>GoDockItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockItemPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockItem</NAME>
struct _GoDockItem
{
  GtkBin bin;

  gchar                *name;

  /* <private> */
  GdkWindow            *bin_window; /* parent window for children */
  GdkWindow            *float_window; /* always NULL */
  GtkShadowType         shadow_type;

  /* Start drag position (wrt widget->window).  */
  gint16                  dragoff_x, dragoff_y;

  /* Position of the floating window.  */
  gint16                  float_x, float_y;

  guint                 behavior : 5;
  guint                 orientation : 1;

  guint                 float_window_mapped : 1;
  guint                 is_floating : 1;
  guint                 in_drag : 1;
  /* If TRUE, the pointer must be grabbed on "map_event".  */
  guint                 grab_on_map_event : 1;

  /*< private >*/
  GoDockItemPrivate *_priv;
};
</STRUCT>
<STRUCT>
<NAME>GoDockItemClass</NAME>
struct _GoDockItemClass
{
  GtkBinClass parent_class;

  void (* dock_drag_begin) (GoDockItem *item);
  void (* dock_drag_motion) (GoDockItem *item, gint x, gint y);
  void (* dock_drag_end) (GoDockItem *item);
  void (* dock_detach) (GoDockItem *item);
  void (* orientation_changed) (GoDockItem *item, GtkOrientation new_orientation);

  gpointer dummy[4];
};
</STRUCT>
<FUNCTION>
<NAME>go_dock_item_get_type</NAME>
<RETURNS>GtkType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_new</NAME>
<RETURNS>GtkWidget     *</RETURNS>
const gchar *name,GoDockItemBehavior behavior
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_construct</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *new_item,const gchar *name,GoDockItemBehavior behavior
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_child</NAME>
<RETURNS>GtkWidget     *</RETURNS>
GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_name</NAME>
<RETURNS>char          *</RETURNS>
GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_set_shadow_type</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *dock_item,GtkShadowType type
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_shadow_type</NAME>
<RETURNS>GtkShadowType  </RETURNS>
GoDockItem *dock_item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_set_orientation</NAME>
<RETURNS>gboolean       </RETURNS>
GoDockItem *dock_item,GtkOrientation orientation
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_orientation</NAME>
<RETURNS>GtkOrientation </RETURNS>
GoDockItem *dock_item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_behavior</NAME>
<RETURNS>GoDockItemBehavior</RETURNS>
GoDockItem *dock_item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_set_locked</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *dock_item,gboolean        locked
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_detach</NAME>
<RETURNS>gboolean       </RETURNS>
GoDockItem *item,gint x, gint y
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_attach</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *item,GtkWidget *parent,gint x, gint y
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_unfloat</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_grab_pointer</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_drag_floating</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *item,gint x, gint y
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_handle_size_request</NAME>
<RETURNS>void           </RETURNS>
GoDockItem *item,GtkRequisition *requisition
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_floating_position</NAME>
<RETURNS>void  </RETURNS>
GoDockItem *item,gint *x, gint *y
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_get_grip</NAME>
<RETURNS>GtkWidget     *</RETURNS>
GoDockItem *item
</FUNCTION>
<MACRO>
<NAME>GO_GRAPH_WIDGET_TYPE</NAME>
#define GO_GRAPH_WIDGET_TYPE	(go_graph_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GO_GRAPH_WIDGET</NAME>
#define GO_GRAPH_WIDGET(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_GRAPH_WIDGET_TYPE, GOGraphWidget))
</MACRO>
<MACRO>
<NAME>IS_GO_GRAPH_WIDGET</NAME>
#define IS_GO_GRAPH_WIDGET(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_GRAPH_WIDGET_TYPE))
</MACRO>
<STRUCT>
<NAME>GOGraphWidget</NAME>
</STRUCT>
<STRUCT>
<NAME>GOGraphWidgetClass</NAME>
</STRUCT>
<ENUM>
<NAME>GOGraphWidgetSizeMode</NAME>
typedef enum {
	GO_GRAPH_WIDGET_SIZE_MODE_FIT = 0,
	GO_GRAPH_WIDGET_SIZE_MODE_FIT_WIDTH,
	GO_GRAPH_WIDGET_SIZE_MODE_FIT_HEIGHT,
	GO_GRAPH_WIDGET_SIZE_MODE_FIXED_SIZE
} GOGraphWidgetSizeMode;
</ENUM>
<FUNCTION>
<NAME>go_graph_widget_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_graph_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GogGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>go_graph_widget_set_size_mode</NAME>
<RETURNS>void </RETURNS>
GOGraphWidget         *widget,GOGraphWidgetSizeMode  size_mode,int                    width,int                    height
</FUNCTION>
<FUNCTION>
<NAME>go_graph_widget_get_graph</NAME>
<RETURNS>GogGraph *</RETURNS>
GOGraphWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>go_graph_widget_get_chart</NAME>
<RETURNS>GogChart *</RETURNS>
GOGraphWidget *widget
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_SELECTOR</NAME>
#define GO_TYPE_SELECTOR		(go_selector_get_type ())
</MACRO>
<MACRO>
<NAME>GO_SELECTOR</NAME>
#define GO_SELECTOR(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_SELECTOR, GOSelector))
</MACRO>
<MACRO>
<NAME>GO_SELECTOR_CLASS</NAME>
#define GO_SELECTOR_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_SELECTOR, GOSelectorClass))
</MACRO>
<MACRO>
<NAME>GO_IS_SELECTOR</NAME>
#define GO_IS_SELECTOR(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_SELECTOR))
</MACRO>
<MACRO>
<NAME>GO_IS_SELECTOR_CLASS</NAME>
#define GO_IS_SELECTOR_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_SELECTOR))
</MACRO>
<MACRO>
<NAME>GO_SELECTOR_GET_CLASS</NAME>
#define GO_SELECTOR_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_SELECTOR, GOSelectorClass))
</MACRO>
<STRUCT>
<NAME>GOSelector</NAME>
</STRUCT>
<STRUCT>
<NAME>GOSelectorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GOSelectorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GOSelector</NAME>
struct _GOSelector
{
	GtkHBox parent;

	GOSelectorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GOSelectorClass</NAME>
struct _GOSelectorClass
{
	GtkHBoxClass parent_class;

	/* signals */
	void (*activate)		(GtkWidget *selector);
};
</STRUCT>
<FUNCTION>
<NAME>go_selector_get_type</NAME>
<RETURNS>GType		 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_selector_new</NAME>
<RETURNS>GtkWidget	*</RETURNS>
GOPalette *palette
</FUNCTION>
<FUNCTION>
<NAME>go_selector_get_active</NAME>
<RETURNS>int 		 </RETURNS>
GOSelector *selector, gboolean *is_auto
</FUNCTION>
<FUNCTION>
<NAME>go_selector_set_active</NAME>
<RETURNS>gboolean 	 </RETURNS>
GOSelector *selector, int index
</FUNCTION>
<FUNCTION>
<NAME>go_selector_update_swatch</NAME>
<RETURNS>void 		 </RETURNS>
GOSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>go_selector_activate</NAME>
<RETURNS>void 		 </RETURNS>
GOSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>go_selector_get_user_data</NAME>
<RETURNS>gpointer 	 </RETURNS>
GOSelector *selector
</FUNCTION>
<USER_FUNCTION>
<NAME>GOSelectorDndDataReceived</NAME>
<RETURNS>void </RETURNS>
GOSelector *selector, gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOSelectorDndDataGet</NAME>
<RETURNS>gpointer </RETURNS>
GOSelector *selector
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOSelectorDndFillIcon</NAME>
<RETURNS>void </RETURNS>
GOSelector *selector, GdkPixbuf *pixbuf
</USER_FUNCTION>
<FUNCTION>
<NAME>go_selector_setup_dnd</NAME>
<RETURNS>void 			</RETURNS>
GOSelector *selector,char const *dnd_target,int dnd_length,GOSelectorDndDataGet data_get,GOSelectorDndDataReceived data_received,GOSelectorDndFillIcon fill_icon
</FUNCTION>
<STRUCT>
<NAME>GOColorPalette</NAME>
</STRUCT>
<MACRO>
<NAME>GO_COLOR_PALETTE_TYPE</NAME>
#define GO_COLOR_PALETTE_TYPE     (go_color_palette_get_type ())
</MACRO>
<MACRO>
<NAME>GO_COLOR_PALETTE</NAME>
#define GO_COLOR_PALETTE(obj)     (G_TYPE_CHECK_INSTANCE_CAST((obj), GO_COLOR_PALETTE_TYPE, GOColorPalette))
</MACRO>
<MACRO>
<NAME>GO_COLOR_PALETTE_CLASS</NAME>
#define GO_COLOR_PALETTE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST(k), GO_COLOR_PALETTE_TYPE)
</MACRO>
<MACRO>
<NAME>IS_GO_COLOR_PALETTE</NAME>
#define IS_GO_COLOR_PALETTE(obj)  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GO_COLOR_PALETTE_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_color_palette_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
char const *no_color_label,GOColor default_color,GOColorGroup *color_group
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_make_menu</NAME>
<RETURNS>GtkWidget *</RETURNS>
char const *no_color_label,GOColor default_color,GOColorGroup *color_group,char const *custom_dialog_title,GOColor current_color
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_set_title</NAME>
<RETURNS>void	</RETURNS>
GOColorPalette *p, char const *title
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_set_group</NAME>
<RETURNS>void	</RETURNS>
GOColorPalette *p, GOColorGroup *cg
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_set_current_color</NAME>
<RETURNS>void    </RETURNS>
GOColorPalette *p, GOColor color
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_set_color_to_default</NAME>
<RETURNS>void    </RETURNS>
GOColorPalette *p
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_get_current_color</NAME>
<RETURNS>GOColor </RETURNS>
GOColorPalette *p,gboolean *is_default, gboolean *is_custom
</FUNCTION>
<FUNCTION>
<NAME>go_color_palette_set_allow_alpha</NAME>
<RETURNS>void	</RETURNS>
GOColorPalette *p, gboolean allow_alpha
</FUNCTION>
<MACRO>
<NAME>GO_COMBO_PIXMAPS_TYPE</NAME>
#define GO_COMBO_PIXMAPS_TYPE	(go_combo_pixmaps_get_type ())
</MACRO>
<MACRO>
<NAME>GO_COMBO_PIXMAPS</NAME>
#define GO_COMBO_PIXMAPS(o)	(G_TYPE_CHECK_INSTANCE_CAST((o), GO_COMBO_PIXMAPS_TYPE, GOComboPixmaps))
</MACRO>
<MACRO>
<NAME>IS_GO_COMBO_PIXMAPS</NAME>
#define IS_GO_COMBO_PIXMAPS(o)	(G_TYPE_CHECK_INSTANCE_TYPE((o), GO_COMBO_PIXMAPS_TYPE))
</MACRO>
<STRUCT>
<NAME>GOComboPixmaps</NAME>
</STRUCT>
<STRUCT>
<NAME>GOMenuPixmaps</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_combo_pixmaps_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_combo_pixmaps_new</NAME>
<RETURNS>GOComboPixmaps *</RETURNS>
int ncols
</FUNCTION>
<FUNCTION>
<NAME>go_combo_pixmaps_add_element</NAME>
<RETURNS>void       </RETURNS>
GOComboPixmaps *combo,GdkPixbuf *pixbuf, int id,char const *tooltip
</FUNCTION>
<FUNCTION>
<NAME>go_combo_pixmaps_select_index</NAME>
<RETURNS>gboolean   </RETURNS>
GOComboPixmaps *combo, int index
</FUNCTION>
<FUNCTION>
<NAME>go_combo_pixmaps_select_id</NAME>
<RETURNS>gboolean   </RETURNS>
GOComboPixmaps *combo, int id
</FUNCTION>
<FUNCTION>
<NAME>go_combo_pixmaps_get_selected</NAME>
<RETURNS>int        </RETURNS>
GOComboPixmaps const *combo, int *index
</FUNCTION>
<FUNCTION>
<NAME>go_combo_pixmaps_get_preview</NAME>
<RETURNS>GtkWidget *</RETURNS>
GOComboPixmaps const *combo
</FUNCTION>
<FUNCTION>
<NAME>go_menu_pixmaps_new</NAME>
<RETURNS>GOMenuPixmaps *</RETURNS>
int ncols
</FUNCTION>
<FUNCTION>
<NAME>go_menu_pixmaps_add_element</NAME>
<RETURNS>void       </RETURNS>
GOMenuPixmaps *menu,GdkPixbuf *pixbuf, int id
</FUNCTION>
<FUNCTION>
<NAME>go_gradient_selector_new</NAME>
<RETURNS>GtkWidget	*</RETURNS>
GOGradientDirection initial_direction,GOGradientDirection default_direction
</FUNCTION>
<FUNCTION>
<NAME>go_gradient_selector_set_colors</NAME>
<RETURNS>void 		 </RETURNS>
GOSelector *selector,GOColor start,GOColor stop
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_selector_new</NAME>
<RETURNS>GtkWidget 	*</RETURNS>
GOPatternType initial_type,GOPatternType default_type
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_selector_set_colors</NAME>
<RETURNS>void 		 </RETURNS>
GOSelector *selector,GOColor foreground,GOColor background
</FUNCTION>
<FUNCTION>
<NAME>go_color_selector_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GOColor initial_color,GOColor default_color,char const *color_group
</FUNCTION>
<FUNCTION>
<NAME>go_color_selector_get_color</NAME>
<RETURNS>GOColor    </RETURNS>
GOSelector *selector, gboolean *is_auto
</FUNCTION>
<FUNCTION>
<NAME>go_color_selector_set_color</NAME>
<RETURNS>gboolean   </RETURNS>
GOSelector *selector, GOColor color
</FUNCTION>
<FUNCTION>
<NAME>go_color_selector_set_allow_alpha</NAME>
<RETURNS>void       </RETURNS>
GOSelector *selector, gboolean allow_alpha
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_DOCK_BAND</NAME>
#define GO_TYPE_DOCK_BAND            (go_dock_band_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DOCK_BAND</NAME>
#define GO_DOCK_BAND(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_DOCK_BAND, GoDockBand))
</MACRO>
<MACRO>
<NAME>GO_DOCK_BAND_CLASS</NAME>
#define GO_DOCK_BAND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_DOCK_BAND, GoDockBandClass))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_BAND</NAME>
#define GO_IS_DOCK_BAND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_DOCK_BAND))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_BAND_CLASS</NAME>
#define GO_IS_DOCK_BAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_DOCK_BAND))
</MACRO>
<MACRO>
<NAME>GO_DOCK_BAND_GET_CLASS</NAME>
#define GO_DOCK_BAND_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_DOCK_BAND, GoDockBandClass))
</MACRO>
<STRUCT>
<NAME>GoDockBand</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockBandPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockBandClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockBandChild</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockBand</NAME>
struct _GoDockBand
{
  GtkContainer container;

  GList *children;              /* GoDockBandChild */

  GList *floating_child;        /* GoDockBandChild */

  /* This used to remember the allocation before the drag begin: it is
     necessary to do so because we actually decide what docking action
     happens depending on it, instead of using the current allocation
     (which might be constantly changing while the user drags things
     around).  */
  GtkAllocation drag_allocation;

  guint tot_offsets;

  guint max_space_requisition : 16;
  guint num_children : 8;
  guint new_for_drag : 1;
  guint doing_drag : 1;
  guint orientation : 1;

  /*< private >*/
  GoDockBandPrivate *_priv;
};
</STRUCT>
<STRUCT>
<NAME>GoDockBandClass</NAME>
struct _GoDockBandClass
{
  GtkContainerClass parent_class;

  gpointer dummy[2];
};
</STRUCT>
<STRUCT>
<NAME>GoDockBandChild</NAME>
struct _GoDockBandChild
{
  GtkWidget *widget;

  GtkAllocation drag_allocation;

  /* Maximum (requested) offset from the previous child.  */
  guint16 offset;

  /* Actual offset.  */
  guint16 real_offset;

  guint16 drag_offset;

  guint16 prev_space, foll_space;
  guint16 drag_prev_space, drag_foll_space;

  guint16 max_space_requisition;
};
</STRUCT>
<FUNCTION>
<NAME>go_dock_band_new</NAME>
<RETURNS>GtkWidget     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_get_type</NAME>
<RETURNS>GtkType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_set_orientation</NAME>
<RETURNS>void           </RETURNS>
GoDockBand *band,GtkOrientation orientation
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_get_orientation</NAME>
<RETURNS>GtkOrientation </RETURNS>
GoDockBand *band
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_insert</NAME>
<RETURNS>gboolean       </RETURNS>
GoDockBand *band,GtkWidget *child,guint offset,gint position
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_prepend</NAME>
<RETURNS>gboolean       </RETURNS>
GoDockBand *band,GtkWidget *child,guint offset
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_append</NAME>
<RETURNS>gboolean       </RETURNS>
GoDockBand *band,GtkWidget *child,guint offset
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_set_child_offset</NAME>
<RETURNS>void           </RETURNS>
GoDockBand *band,GtkWidget *child,guint offset
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_get_child_offset</NAME>
<RETURNS>guint          </RETURNS>
GoDockBand *band,GtkWidget *child
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_move_child</NAME>
<RETURNS>void           </RETURNS>
GoDockBand *band,GList *old_child,guint new_num
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_get_num_children</NAME>
<RETURNS>guint          </RETURNS>
GoDockBand *band
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_drag_begin</NAME>
<RETURNS>void           </RETURNS>
GoDockBand *band,GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_drag_to</NAME>
<RETURNS>gboolean       </RETURNS>
GoDockBand *band,GoDockItem *item,gint x, gint y
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_drag_end</NAME>
<RETURNS>void           </RETURNS>
GoDockBand *band,GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_get_item_by_name</NAME>
<RETURNS>GoDockItem *</RETURNS>
GoDockBand *band,const char *name,guint *position_return,guint *offset_return
</FUNCTION>
<FUNCTION>
<NAME>go_dock_band_layout_add</NAME>
<RETURNS>void           </RETURNS>
GoDockBand *band,GoDockLayout *layout,GoDockPlacement placement,guint band_num
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_OPTION_MENU</NAME>
#define GO_TYPE_OPTION_MENU              (go_option_menu_get_type ())
</MACRO>
<MACRO>
<NAME>GO_OPTION_MENU</NAME>
#define GO_OPTION_MENU(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_OPTION_MENU, GOOptionMenu))
</MACRO>
<MACRO>
<NAME>GO_OPTION_MENU_CLASS</NAME>
#define GO_OPTION_MENU_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_OPTION_MENU, GOOptionMenuClass))
</MACRO>
<MACRO>
<NAME>GO_IS_OPTION_MENU</NAME>
#define GO_IS_OPTION_MENU(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_OPTION_MENU))
</MACRO>
<MACRO>
<NAME>GO_IS_OPTION_MENU_CLASS</NAME>
#define GO_IS_OPTION_MENU_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_OPTION_MENU))
</MACRO>
<MACRO>
<NAME>GO_OPTION_MENU_GET_CLASS</NAME>
#define GO_OPTION_MENU_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_OPTION_MENU, GOOptionMenuClass))
</MACRO>
<STRUCT>
<NAME>GOOptionMenu</NAME>
</STRUCT>
<STRUCT>
<NAME>GOOptionMenuClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GOOptionMenu</NAME>
struct _GOOptionMenu
{
	GtkButton button;

	/*< private >*/

	GtkMenuShell *menu;
	GtkMenuItem *selected;
	GtkLabel *button_label;
};
</STRUCT>
<STRUCT>
<NAME>GOOptionMenuClass</NAME>
struct _GOOptionMenuClass
{
  GtkButtonClass parent_class;

  void (*changed) (GOOptionMenu *option_menu);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>go_option_menu_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_option_menu_new</NAME>
<RETURNS>GtkWidget*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_option_menu_set_menu</NAME>
<RETURNS>void       </RETURNS>
GOOptionMenu *option_menu,GtkWidget *menu
</FUNCTION>
<FUNCTION>
<NAME>go_option_menu_set_history</NAME>
<RETURNS>void       </RETURNS>
GOOptionMenu *option_menu,GSList *selection
</FUNCTION>
<FUNCTION>
<NAME>go_option_menu_get_history</NAME>
<RETURNS>GtkWidget *</RETURNS>
GOOptionMenu *option_menu
</FUNCTION>
<MACRO>
<NAME>GO_COMBO_COLOR_TYPE</NAME>
#define GO_COMBO_COLOR_TYPE	(go_combo_color_get_type ())
</MACRO>
<MACRO>
<NAME>GO_COMBO_COLOR</NAME>
#define GO_COMBO_COLOR(o)	(G_TYPE_CHECK_INSTANCE_CAST((o), GO_COMBO_COLOR_TYPE, GOComboColor))
</MACRO>
<MACRO>
<NAME>IS_GO_COMBO_COLOR</NAME>
#define IS_GO_COMBO_COLOR(o)	(G_TYPE_CHECK_INSTANCE_TYPE((o), GO_COMBO_COLOR_TYPE))
</MACRO>
<MACRO>
<NAME>GO_COMBO_COLOR_CLASS</NAME>
#define GO_COMBO_COLOR_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST(k), GO_COMBO_COLOR_TYPE)
</MACRO>
<STRUCT>
<NAME>GOComboColor</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_combo_color_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkPixbuf   *icon,char const *no_color_label,GOColor default_color,GOColorGroup  *color_group
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_get_color</NAME>
<RETURNS>GOColor </RETURNS>
GOComboColor  *cc, gboolean *is_default
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_set_color</NAME>
<RETURNS>void    </RETURNS>
GOComboColor  *cc, GOColor   color
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_set_color_to_default</NAME>
<RETURNS>void    </RETURNS>
GOComboColor *cc
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_set_color_gdk</NAME>
<RETURNS>void    </RETURNS>
GOComboColor *cc, GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_set_allow_alpha</NAME>
<RETURNS>void </RETURNS>
GOComboColor *cc, gboolean allow_alpha
</FUNCTION>
<FUNCTION>
<NAME>go_combo_color_set_instant_apply</NAME>
<RETURNS>void </RETURNS>
GOComboColor *cc, gboolean active
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_COMBO_TEXT</NAME>
#define GO_TYPE_COMBO_TEXT	(go_combo_text_get_type ())
</MACRO>
<MACRO>
<NAME>GO_COMBO_TEXT</NAME>
#define GO_COMBO_TEXT(obj)	(G_TYPE_CHECK_INSTANCE_CAST (obj, GO_TYPE_COMBO_TEXT, GoComboText))
</MACRO>
<MACRO>
<NAME>IS_GO_COMBO_TEXT</NAME>
#define IS_GO_COMBO_TEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE (obj, GO_TYPE_COMBO_TEXT))
</MACRO>
<STRUCT>
<NAME>GoComboText</NAME>
</STRUCT>
<ENUM>
<NAME>GoComboTextSearch</NAME>
typedef enum {		/* begin the search from : */
	GO_COMBO_TEXT_FROM_TOP,	/* the top of the list */
	GO_COMBO_TEXT_CURRENT,		/* the current selection */
	GO_COMBO_TEXT_NEXT		/* the next element after current */
} GoComboTextSearch;
</ENUM>
<FUNCTION>
<NAME>go_combo_text_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_combo_text_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GCompareFunc cmp_func
</FUNCTION>
<FUNCTION>
<NAME>go_combo_text_glade_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_combo_text_get_entry</NAME>
<RETURNS>GtkWidget *</RETURNS>
GoComboText *ct
</FUNCTION>
<FUNCTION>
<NAME>go_combo_text_set_text</NAME>
<RETURNS>gboolean   </RETURNS>
GoComboText *ct, const gchar *text,GoComboTextSearch start
</FUNCTION>
<FUNCTION>
<NAME>go_combo_text_add_item</NAME>
<RETURNS>void	   </RETURNS>
GoComboText *ct, const gchar *label
</FUNCTION>
<MACRO>
<NAME>GO_ACTION_COMBO_PIXMAPS_TYPE</NAME>
#define GO_ACTION_COMBO_PIXMAPS_TYPE  (go_action_combo_pixmaps_get_type ())
</MACRO>
<MACRO>
<NAME>GO_ACTION_COMBO_PIXMAPS</NAME>
#define GO_ACTION_COMBO_PIXMAPS(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_ACTION_COMBO_PIXMAPS_TYPE, GOActionComboPixmaps))
</MACRO>
<MACRO>
<NAME>IS_GO_ACTION_COMBO_PIXMAPS</NAME>
#define IS_GO_ACTION_COMBO_PIXMAPS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_ACTION_COMBO_PIXMAPS_TYPE))
</MACRO>
<STRUCT>
<NAME>GOActionComboPixmaps</NAME>
</STRUCT>
<STRUCT>
<NAME>GOActionComboPixmapsElement</NAME>
typedef struct {
	char const *untranslated_tooltip;
	char const *stock_id;
	int id;
} GOActionComboPixmapsElement;
</STRUCT>
<FUNCTION>
<NAME>go_action_combo_pixmaps_get_type</NAME>
<RETURNS>GType	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_pixmaps_new</NAME>
<RETURNS>GOActionComboPixmaps  *</RETURNS>
char const *name,GOActionComboPixmapsElement const *elements,int ncols, int nrows
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_pixmaps_get_selected</NAME>
<RETURNS>int	 </RETURNS>
GOActionComboPixmaps *action, int *indx
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_pixmaps_select_id</NAME>
<RETURNS>gboolean </RETURNS>
GOActionComboPixmaps *action, int id
</FUNCTION>
<MACRO>
<NAME>GO_CHARMAP_SEL_TYPE</NAME>
#define GO_CHARMAP_SEL_TYPE        (go_charmap_sel_get_type ())
</MACRO>
<MACRO>
<NAME>GO_CHARMAP_SEL</NAME>
#define GO_CHARMAP_SEL(obj)        (G_TYPE_CHECK_INSTANCE_CAST((obj), GO_CHARMAP_SEL_TYPE, GOCharmapSel))
</MACRO>
<MACRO>
<NAME>IS_GO_CHARMAP_SEL</NAME>
#define IS_GO_CHARMAP_SEL(obj)     (G_TYPE_CHECK_INSTANCE_TYPE((obj), GO_CHARMAP_SEL_TYPE))
</MACRO>
<STRUCT>
<NAME>GOCharmapSel</NAME>
</STRUCT>
<ENUM>
<NAME>GOCharmapSelTestDirection</NAME>
typedef enum {
	GO_CHARMAP_SEL_TO_UTF8 = 0,
	GO_CHARMAP_SEL_FROM_UTF8
} GOCharmapSelTestDirection;
</ENUM>
<FUNCTION>
<NAME>go_charmap_sel_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_charmap_sel_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GOCharmapSelTestDirection test
</FUNCTION>
<FUNCTION>
<NAME>go_charmap_sel_get_encoding</NAME>
<RETURNS>gchar const *</RETURNS>
GOCharmapSel *cs
</FUNCTION>
<FUNCTION>
<NAME>go_charmap_sel_set_encoding</NAME>
<RETURNS>gboolean     </RETURNS>
GOCharmapSel *cs, const char *enc
</FUNCTION>
<FUNCTION>
<NAME>go_charmap_sel_get_encoding_name</NAME>
<RETURNS>const char  *</RETURNS>
GOCharmapSel *cs, const char *enc
</FUNCTION>
<MACRO>
<NAME>GO_COMBO_BOX_TYPE</NAME>
#define GO_COMBO_BOX_TYPE	(go_combo_box_get_type())
</MACRO>
<MACRO>
<NAME>GO_COMBO_BOX</NAME>
#define GO_COMBO_BOX(o)		G_TYPE_CHECK_INSTANCE_CAST ((o), GO_COMBO_BOX_TYPE, GOComboBox)
</MACRO>
<MACRO>
<NAME>IS_GO_COMBO_BOX</NAME>
#define IS_GO_COMBO_BOX(o)	G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_COMBO_BOX_TYPE)
</MACRO>
<MACRO>
<NAME>GO_COMBO_BOX_CLASS</NAME>
#define GO_COMBO_BOX_CLASS(k)	G_TYPE_CHECK_CLASS_CAST ((k), GO_COMBO_BOX_TYPE, GOComboBoxClass)
</MACRO>
<STRUCT>
<NAME>GOComboBox</NAME>
</STRUCT>
<STRUCT>
<NAME>GOComboBoxPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GOComboBoxClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GOComboBox</NAME>
struct _GOComboBox {
	GtkHBox hbox;
	GOComboBoxPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GOComboBoxClass</NAME>
struct _GOComboBoxClass {
	GtkHBoxClass	base;

	/* virtual */
	void  (*set_title) (GOComboBox *cbox, char const *title);

	/* invoked when the popup has been hidden, if the signal
	 * returns TRUE, it means it should be killed */
	gboolean   (*pop_down_done)   (GOComboBox *cbox, GtkWidget *);
};
</STRUCT>
<FUNCTION>
<NAME>go_combo_box_get_type</NAME>
<RETURNS>GType	    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_set_tooltip</NAME>
<RETURNS>void	    </RETURNS>
GOComboBox *combo, void *tips,char const *text, char const *priv_text
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_set_relief</NAME>
<RETURNS>void	    </RETURNS>
GOComboBox *combo, GtkReliefStyle relief
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_set_title</NAME>
<RETURNS>void	    </RETURNS>
GOComboBox *combo, char const *title
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_get_title</NAME>
<RETURNS>char const *</RETURNS>
GOComboBox *combo
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_set_tearable</NAME>
<RETURNS>void	    </RETURNS>
GOComboBox *combo, gboolean tearable
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_construct</NAME>
<RETURNS>void </RETURNS>
GOComboBox *combo,GtkWidget  *display_widget,GtkWidget  *popdown_container,GtkWidget  *popdown_focus
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_get_pos</NAME>
<RETURNS>void </RETURNS>
GOComboBox *combo, int *x, int *y
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_popup_hide</NAME>
<RETURNS>void </RETURNS>
GOComboBox *combo
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_popup_display</NAME>
<RETURNS>void </RETURNS>
GOComboBox *combo
</FUNCTION>
<FUNCTION>
<NAME>go_combo_box_set_display</NAME>
<RETURNS>void </RETURNS>
GOComboBox *combo,GtkWidget *display_widget
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_DOCK_LAYOUT</NAME>
#define GO_TYPE_DOCK_LAYOUT            (go_dock_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DOCK_LAYOUT</NAME>
#define GO_DOCK_LAYOUT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_DOCK_LAYOUT, GoDockLayout))
</MACRO>
<MACRO>
<NAME>GO_DOCK_LAYOUT_CLASS</NAME>
#define GO_DOCK_LAYOUT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_DOCK_LAYOUT, GoDockLayoutClass))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_LAYOUT</NAME>
#define GO_IS_DOCK_LAYOUT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_DOCK_LAYOUT))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_LAYOUT_CLASS</NAME>
#define GO_IS_DOCK_LAYOUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_DOCK_LAYOUT))
</MACRO>
<MACRO>
<NAME>GO_DOCK_LAYOUT_GET_CLASS</NAME>
#define GO_DOCK_LAYOUT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_DOCK_LAYOUT, GoDockLayoutClass))
</MACRO>
<STRUCT>
<NAME>GoDockLayoutItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockLayoutClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockLayoutPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockLayoutItem</NAME>
struct _GoDockLayoutItem
{
  GoDockItem *item;

  GoDockPlacement placement;

  union
  {
    struct
    {
      gint x;
      gint y;
      GtkOrientation orientation;
    } floating;

    struct
    {
      gint band_num;
      gint band_position;
      gint offset;
    } docked;

  } position;
};
</STRUCT>
<STRUCT>
<NAME>GoDockLayout</NAME>
struct _GoDockLayout
{
  GObject object;

  GList *items;                 /* GoDockLayoutItem */

  /*< private >*/
  GoDockLayoutPrivate *_priv;
};
</STRUCT>
<STRUCT>
<NAME>GoDockLayoutClass</NAME>
struct _GoDockLayoutClass
{
  GObjectClass parent_class;

  gpointer dummy[4];
};
</STRUCT>
<FUNCTION>
<NAME>go_dock_layout_new</NAME>
<RETURNS>GoDockLayout     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_add_item</NAME>
<RETURNS>gboolean             </RETURNS>
GoDockLayout *layout,GoDockItem *item,GoDockPlacement placement,gint band_num,gint band_position,gint offset
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_add_floating_item</NAME>
<RETURNS>gboolean  </RETURNS>
GoDockLayout *layout,GoDockItem *item,gint x, gint y,GtkOrientation orientation
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_get_item</NAME>
<RETURNS>GoDockLayoutItem *</RETURNS>
GoDockLayout *layout,GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_get_item_by_name</NAME>
<RETURNS>GoDockLayoutItem  *</RETURNS>
GoDockLayout *layout,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_remove_item</NAME>
<RETURNS>gboolean  </RETURNS>
GoDockLayout *layout,GoDockItem *item
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_remove_item_by_name</NAME>
<RETURNS>gboolean  </RETURNS>
GoDockLayout *layout,const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_create_string</NAME>
<RETURNS>gchar                *</RETURNS>
GoDockLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_parse_string</NAME>
<RETURNS>gboolean  </RETURNS>
GoDockLayout *layout,const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>go_dock_layout_add_to_dock</NAME>
<RETURNS>gboolean  </RETURNS>
GoDockLayout *layout,GoDock *dock
</FUNCTION>
<FUNCTION>
<NAME>go_pixbuf_intelligent_scale</NAME>
<RETURNS>GdkPixbuf 	*</RETURNS>
GdkPixbuf *buf,guint width, guint height
</FUNCTION>
<FUNCTION>
<NAME>go_pixbuf_new_from_file</NAME>
<RETURNS>GdkPixbuf 	*</RETURNS>
char const *filename
</FUNCTION>
<FUNCTION>
<NAME>go_pixbuf_get_from_cache</NAME>
<RETURNS>GdkPixbuf 	*</RETURNS>
char const *filename
</FUNCTION>
<FUNCTION>
<NAME>go_pixbuf_tile</NAME>
<RETURNS>GdkPixbuf	*</RETURNS>
GdkPixbuf const *src,guint w, guint h
</FUNCTION>
<MACRO>
<NAME>GO_FORMAT_SEL_TYPE</NAME>
#define GO_FORMAT_SEL_TYPE	(go_format_sel_get_type ())
</MACRO>
<MACRO>
<NAME>GO_FORMAT_SEL</NAME>
#define GO_FORMAT_SEL(o)	(G_TYPE_CHECK_INSTANCE_CAST((o), GO_FORMAT_SEL_TYPE, GOFormatSel))
</MACRO>
<MACRO>
<NAME>IS_GO_FORMAT_SEL</NAME>
#define IS_GO_FORMAT_SEL(o)	(G_TYPE_CHECK_INSTANCE_TYPE((o), GO_FORMAT_SEL_TYPE))
</MACRO>
<STRUCT>
<NAME>GOFormatSel</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_format_sel_get_type</NAME>
<RETURNS>GType		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_new_full</NAME>
<RETURNS>GtkWidget *</RETURNS>
gboolean use_markup
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_set_focus</NAME>
<RETURNS>void		</RETURNS>
GOFormatSel *gfs
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_set_style_format</NAME>
<RETURNS>void		</RETURNS>
GOFormatSel *gfs,GOFormat *style_format
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_set_locale</NAME>
<RETURNS>void		</RETURNS>
GOFormatSel *gfs,char const *locale
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_get_fmt</NAME>
<RETURNS>GOFormat *</RETURNS>
GOFormatSel *gfs
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_set_dateconv</NAME>
<RETURNS>void	  </RETURNS>
GOFormatSel *gfs,GODateConventions const *date_conv
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_show_preview</NAME>
<RETURNS>void	  </RETURNS>
GOFormatSel *gfs
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_hide_preview</NAME>
<RETURNS>void	  </RETURNS>
GOFormatSel *gfs
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_editable_enters</NAME>
<RETURNS>void	  </RETURNS>
GOFormatSel *gfs,GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>go_format_sel_format_classification</NAME>
<RETURNS>char const *</RETURNS>
GOFormat const *style_format
</FUNCTION>
<MACRO>
<NAME>GO_ACTION_COMBO_COLOR_TYPE</NAME>
#define GO_ACTION_COMBO_COLOR_TYPE  (go_action_combo_color ())
</MACRO>
<MACRO>
<NAME>GO_ACTION_COMBO_COLOR</NAME>
#define GO_ACTION_COMBO_COLOR(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_ACTION_COMBO_COLOR_TYPE, GOActionComboColor))
</MACRO>
<MACRO>
<NAME>IS_GO_ACTION_COMBO_COLOR</NAME>
#define IS_GO_ACTION_COMBO_COLOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_ACTION_COMBO_COLOR_TYPE))
</MACRO>
<STRUCT>
<NAME>GOActionComboColor</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_action_combo_color_get_type</NAME>
<RETURNS>GType	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_color_new</NAME>
<RETURNS>GOActionComboColor  *</RETURNS>
char const  *action_name,char const  *stock_id,char const  *default_color_label,GOColor	default_color,gpointer	group_key
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_color_set_group</NAME>
<RETURNS>void 	</RETURNS>
GOActionComboColor *a, gpointer group_key
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_color_get_color</NAME>
<RETURNS>GOColor </RETURNS>
GOActionComboColor *a, gboolean *is_default
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_color_set_color</NAME>
<RETURNS>void    </RETURNS>
GOActionComboColor *a, GOColor color
</FUNCTION>
<FUNCTION>
<NAME>go_line_dash_selector_new</NAME>
<RETURNS>GtkWidget	*</RETURNS>
GOLineDashType initial_type,GOLineDashType default_type
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_editable_enters</NAME>
<RETURNS>void	   </RETURNS>
GtkWindow *window, GtkWidget *w
</FUNCTION>
<MACRO>
<NAME>go_libglade_new</NAME>
#define go_libglade_new	go_glade_new
</MACRO>
<FUNCTION>
<NAME>go_glade_new</NAME>
<RETURNS>GladeXML  *</RETURNS>
char const *gladefile, char const *root,char const *domain, GOCmdContext *cc
</FUNCTION>
<FUNCTION>
<NAME>go_glade_signal_connect</NAME>
<RETURNS>gulong	   </RETURNS>
GladeXML *gui,gchar const *instance_name,gchar const *detailed_signal,GCallback	 c_handler,gpointer	 data
</FUNCTION>
<FUNCTION>
<NAME>go_glade_signal_connect_swapped</NAME>
<RETURNS>gulong	   </RETURNS>
GladeXML *gui,gchar const *instance_name,gchar const *detailed_signal,GCallback	 c_handler,gpointer	 data
</FUNCTION>
<FUNCTION>
<NAME>go_pango_measure_string</NAME>
<RETURNS>int	   </RETURNS>
PangoContext *context,PangoFontDescription const *font_desc,char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_dialog_run</NAME>
<RETURNS>gint       </RETURNS>
GtkDialog *dialog, GtkWindow *parent
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_dialog_add_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog *dialog, char const *text, char const *stock_id,gint response_id
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_notice_dialog</NAME>
<RETURNS>void       </RETURNS>
GtkWindow *parent, GtkMessageType type,const gchar *format, ...
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_notice_nonmodal_dialog</NAME>
<RETURNS>void       </RETURNS>
GtkWindow *parent, GtkWidget **ref,GtkMessageType type, const gchar *format, ...
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_query_yes_no</NAME>
<RETURNS>gboolean   </RETURNS>
GtkWindow *toplevel, gboolean default_answer,const gchar *format, ...
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_button_new_with_stock</NAME>
<RETURNS>GtkWidget *</RETURNS>
char const *text,char const *stock_id
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_widget_disable_focus</NAME>
<RETURNS>void	   </RETURNS>
GtkWidget *w
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_window_set_transient</NAME>
<RETURNS>void       </RETURNS>
GtkWindow *toplevel, GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_help_button_init</NAME>
<RETURNS>void	   </RETURNS>
GtkWidget *w, char const *data_dir,char const *app, char const *link
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_nonmodal_dialog</NAME>
<RETURNS>void       </RETURNS>
GtkWindow *toplevel, GtkWindow *dialog
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_file_sel_dialog</NAME>
<RETURNS>gboolean   </RETURNS>
GtkWindow *toplevel, GtkWidget *w
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_select_image</NAME>
<RETURNS>char	  *</RETURNS>
GtkWindow *toplevel, const char *initial
</FUNCTION>
<FUNCTION>
<NAME>go_gui_get_image_save_info</NAME>
<RETURNS>char      *</RETURNS>
GtkWindow *toplevel, GSList *supported_formats,GOImageFormat *ret_format, double *dpi
</FUNCTION>
<FUNCTION>
<NAME>go_gtk_url_is_writeable</NAME>
<RETURNS>gboolean   </RETURNS>
GtkWindow *parent, char const *uri,gboolean overwrite_by_default
</FUNCTION>
<FUNCTION>
<NAME>go_atk_setup_label</NAME>
<RETURNS>void	   </RETURNS>
GtkWidget *label, GtkWidget *target
</FUNCTION>
<FUNCTION>
<NAME>go_dialog_guess_alternative_button_order</NAME>
<RETURNS>void       </RETURNS>
GtkDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>go_widget_set_tooltip_text</NAME>
<RETURNS>void       </RETURNS>
GtkWidget *widget, const gchar *tip
</FUNCTION>
<FUNCTION>
<NAME>go_tool_item_set_tooltip_text</NAME>
<RETURNS>void       </RETURNS>
GtkToolItem *item, const gchar *tip
</FUNCTION>
<FUNCTION>
<NAME>go_menu_position_below</NAME>
<RETURNS>void 	   </RETURNS>
GtkMenu *menu, gint *x, gint *y,gint *push_in, gpointer user_data
</FUNCTION>
<MACRO>
<NAME>GO_ACTION_COMBO_TEXT_TYPE</NAME>
#define GO_ACTION_COMBO_TEXT_TYPE  (go_action_combo_text_get_type ())
</MACRO>
<MACRO>
<NAME>GO_ACTION_COMBO_TEXT</NAME>
#define GO_ACTION_COMBO_TEXT(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_ACTION_COMBO_TEXT_TYPE, GOActionComboText))
</MACRO>
<MACRO>
<NAME>IS_GO_ACTION_COMBO_TEXT</NAME>
#define IS_GO_ACTION_COMBO_TEXT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_ACTION_COMBO_TEXT_TYPE))
</MACRO>
<STRUCT>
<NAME>GOActionComboText</NAME>
</STRUCT>
<ENUM>
<NAME>GOActionComboTextSearchDir</NAME>
typedef enum {		/* begin the search from : */
	GO_ACTION_COMBO_SEARCH_FROM_TOP,	/* the top of the list */
	GO_ACTION_COMBO_SEARCH_CURRENT,		/* the current selection */
	GO_ACTION_COMBO_SEARCH_NEXT		/* the next element after current */
} GOActionComboTextSearchDir;
</ENUM>
<FUNCTION>
<NAME>go_action_combo_text_get_type</NAME>
<RETURNS>GType	    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_text_add_item</NAME>
<RETURNS>void	    </RETURNS>
GOActionComboText       *a,char const *item
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_text_set_width</NAME>
<RETURNS>void        </RETURNS>
GOActionComboText       *a,char const *largest_elem
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_text_get_entry</NAME>
<RETURNS>char const *</RETURNS>
GOActionComboText const *a
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_text_set_entry</NAME>
<RETURNS>void	    </RETURNS>
GOActionComboText       *a,char const *text,GOActionComboTextSearchDir dir
</FUNCTION>
<MACRO>
<NAME>GO_ACTION_COMBO_STACK_TYPE</NAME>
#define GO_ACTION_COMBO_STACK_TYPE  (go_action_combo_stack_get_type ())
</MACRO>
<MACRO>
<NAME>GO_ACTION_COMBO_STACK</NAME>
#define GO_ACTION_COMBO_STACK(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_ACTION_COMBO_STACK_TYPE, GOActionComboStack))
</MACRO>
<MACRO>
<NAME>IS_GO_ACTION_COMBO_STACK</NAME>
#define IS_GO_ACTION_COMBO_STACK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_ACTION_COMBO_STACK_TYPE))
</MACRO>
<STRUCT>
<NAME>GOActionComboStack</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_action_combo_stack_get_type</NAME>
<RETURNS>GType	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_stack_push</NAME>
<RETURNS>void	 </RETURNS>
GOActionComboStack *a,char const *str, gpointer key
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_stack_pop</NAME>
<RETURNS>void	 </RETURNS>
GOActionComboStack *a, unsigned n
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_stack_truncate</NAME>
<RETURNS>void	 </RETURNS>
GOActionComboStack *a, unsigned n
</FUNCTION>
<FUNCTION>
<NAME>go_action_combo_stack_selection</NAME>
<RETURNS>gpointer </RETURNS>
GOActionComboStack const *a
</FUNCTION>
<MACRO>
<NAME>GO_LOCALE_SEL_TYPE</NAME>
#define GO_LOCALE_SEL_TYPE        (go_locale_sel_get_type ())
</MACRO>
<MACRO>
<NAME>GO_LOCALE_SEL</NAME>
#define GO_LOCALE_SEL(obj)        (G_TYPE_CHECK_INSTANCE_CAST((obj), GO_LOCALE_SEL_TYPE, GOLocaleSel))
</MACRO>
<MACRO>
<NAME>IS_GO_LOCALE_SEL</NAME>
#define IS_GO_LOCALE_SEL(obj)     (G_TYPE_CHECK_INSTANCE_TYPE((obj), GO_LOCALE_SEL_TYPE))
</MACRO>
<STRUCT>
<NAME>GOLocaleSel</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_locale_sel_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_sel_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_sel_get_locale</NAME>
<RETURNS>gchar       *</RETURNS>
GOLocaleSel *cs
</FUNCTION>
<FUNCTION>
<NAME>go_locale_sel_set_locale</NAME>
<RETURNS>gboolean     </RETURNS>
GOLocaleSel *cs, const char *loc
</FUNCTION>
<FUNCTION>
<NAME>go_locale_sel_set_sensitive</NAME>
<RETURNS>void         </RETURNS>
GOLocaleSel *cs, gboolean sensitive
</FUNCTION>
<FUNCTION>
<NAME>go_locale_sel_get_locale_name</NAME>
<RETURNS>const char  *</RETURNS>
GOLocaleSel *cs, const char *loc
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_DOCK_ITEM_GRIP</NAME>
#define GO_TYPE_DOCK_ITEM_GRIP            (go_dock_item_grip_get_type())
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM_GRIP</NAME>
#define GO_DOCK_ITEM_GRIP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_DOCK_ITEM_GRIP, GoDockItemGrip))
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM_GRIP_CLASS</NAME>
#define GO_DOCK_ITEM_GRIP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_DOCK_ITEM_GRIP, GoDockItemGripClass))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_ITEM_GRIP</NAME>
#define GO_IS_DOCK_ITEM_GRIP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_DOCK_ITEM_GRIP))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_ITEM_GRIP_CLASS</NAME>
#define GO_IS_DOCK_ITEM_GRIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_DOCK_ITEM_GRIP))
</MACRO>
<MACRO>
<NAME>GO_DOCK_ITEM_GRIP_GET_CLASS</NAME>
#define GO_DOCK_ITEM_GRIP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_DOCK_ITEM_GRIP, GoDockItemGripClass))
</MACRO>
<STRUCT>
<NAME>GoDockItemGrip</NAME>
typedef struct {
	GtkWidget parent;

	GoDockItem *item;
} GoDockItemGrip;
</STRUCT>
<STRUCT>
<NAME>GoDockItemGripClass</NAME>
typedef struct {
	GtkWidgetClass parent_class;

	void (*activate) (GoDockItemGrip *grip);
} GoDockItemGripClass;
</STRUCT>
<FUNCTION>
<NAME>go_dock_item_grip_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_item_grip_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GoDockItem *item
</FUNCTION>
<MACRO>
<NAME>GO_TYPE_DOCK</NAME>
#define GO_TYPE_DOCK            (go_dock_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DOCK</NAME>
#define GO_DOCK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_DOCK, GoDock))
</MACRO>
<MACRO>
<NAME>GO_DOCK_CLASS</NAME>
#define GO_DOCK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_DOCK, GoDockClass))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK</NAME>
#define GO_IS_DOCK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_DOCK))
</MACRO>
<MACRO>
<NAME>GO_IS_DOCK_CLASS</NAME>
#define GO_IS_DOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_DOCK))
</MACRO>
<MACRO>
<NAME>GO_DOCK_GET_CLASS</NAME>
#define GO_DOCK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_DOCK, GoDockClass))
</MACRO>
<ENUM>
<NAME>GoDockPlacement</NAME>
typedef enum
{
  GO_DOCK_TOP,
  GO_DOCK_RIGHT,
  GO_DOCK_BOTTOM,
  GO_DOCK_LEFT,
  GO_DOCK_FLOATING
} GoDockPlacement;
</ENUM>
<STRUCT>
<NAME>GoDock</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDockClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GoDock</NAME>
struct _GoDock
{
  GtkContainer container;

  GtkWidget *client_area;

  /* GoDockBands associated with this dock.  */
  GList *top_bands;
  GList *bottom_bands;
  GList *right_bands;
  GList *left_bands;

  /* Children that are currently not docked.  */
  GList *floating_children;     /* GtkWidget */

  /* Client rectangle before drag.  */
  GtkAllocation client_rect;

  guint floating_items_allowed : 1;

  /*< private >*/
  GoDockPrivate *_priv;
};
</STRUCT>
<STRUCT>
<NAME>GoDockClass</NAME>
struct _GoDockClass
{
  GtkContainerClass parent_class;

  void (* layout_changed) (GoDock *dock);

  gpointer dummy[4];
};
</STRUCT>
<FUNCTION>
<NAME>go_dock_new</NAME>
<RETURNS>GtkWidget     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_get_type</NAME>
<RETURNS>GtkType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_dock_allow_floating_items</NAME>
<RETURNS>void  </RETURNS>
GoDock *dock,gboolean enable
</FUNCTION>
<FUNCTION>
<NAME>go_dock_add_item</NAME>
<RETURNS>void           </RETURNS>
GoDock             *dock,GoDockItem         *item,GoDockPlacement  placement,guint                  band_num,gint                   position,guint                  offset,gboolean               in_new_band
</FUNCTION>
<FUNCTION>
<NAME>go_dock_add_floating_item</NAME>
<RETURNS>void           </RETURNS>
GoDock *dock,GoDockItem *item,gint x, gint y,GtkOrientation orientation
</FUNCTION>
<FUNCTION>
<NAME>go_dock_set_client_area</NAME>
<RETURNS>void             </RETURNS>
GoDock             *dock,GtkWidget             *widget
</FUNCTION>
<FUNCTION>
<NAME>go_dock_get_client_area</NAME>
<RETURNS>GtkWidget       *</RETURNS>
GoDock             *dock
</FUNCTION>
<FUNCTION>
<NAME>go_dock_get_item_by_name</NAME>
<RETURNS>GoDockItem  *</RETURNS>
GoDock *dock,const gchar *name,GoDockPlacement *placement_return,guint *num_band_return,guint *band_position_return,guint *offset_return
</FUNCTION>
<FUNCTION>
<NAME>go_dock_get_layout</NAME>
<RETURNS>GoDockLayout *</RETURNS>
GoDock *dock
</FUNCTION>
<FUNCTION>
<NAME>go_dock_add_from_layout</NAME>
<RETURNS>gboolean          </RETURNS>
GoDock *dock,GoDockLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>go_marker_selector_new</NAME>
<RETURNS>GtkWidget	*</RETURNS>
GOMarkerShape initial_shape,GOMarkerShape default_shape
</FUNCTION>
<FUNCTION>
<NAME>go_marker_selector_set_colors</NAME>
<RETURNS>void 		 </RETURNS>
GOSelector *selector,GOColor outline,GOColor fill
</FUNCTION>
<MACRO>
<NAME>GO_ROTATION_SEL_TYPE</NAME>
#define GO_ROTATION_SEL_TYPE	(go_rotation_sel_get_type ())
</MACRO>
<MACRO>
<NAME>GO_ROTATION_SEL</NAME>
#define GO_ROTATION_SEL(obj)	(G_TYPE_CHECK_INSTANCE_CAST((obj), GO_ROTATION_SEL_TYPE, GORotationSel))
</MACRO>
<MACRO>
<NAME>IS_GO_ROTATION_SEL</NAME>
#define IS_GO_ROTATION_SEL(obj)	(G_TYPE_CHECK_INSTANCE_TYPE((obj), GO_ROTATION_SEL_TYPE))
</MACRO>
<STRUCT>
<NAME>GORotationSel</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_rotation_sel_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_rotation_sel_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_rotation_sel_set_rotation</NAME>
<RETURNS>void	   </RETURNS>
GORotationSel *rs, int degrees
</FUNCTION>
<FUNCTION>
<NAME>go_rotation_sel_get_rotation</NAME>
<RETURNS>int	   </RETURNS>
GORotationSel const *rs
</FUNCTION>
<MACRO>
<NAME>GO_COLOR_GROUP_HISTORY_SIZE</NAME>
#define GO_COLOR_GROUP_HISTORY_SIZE	8
</MACRO>
<STRUCT>
<NAME>GOColorGroup</NAME>
typedef struct {
	GObject  parent;

        char	  *name;
	gpointer   context;

        GOColor	history[GO_COLOR_GROUP_HISTORY_SIZE];
} GOColorGroup;
</STRUCT>
<MACRO>
<NAME>GO_COLOR_GROUP_TYPE</NAME>
#define GO_COLOR_GROUP_TYPE     (go_color_group_get_type ())
</MACRO>
<MACRO>
<NAME>GO_COLOR_GROUP</NAME>
#define GO_COLOR_GROUP(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_COLOR_GROUP_TYPE, GOColorGroup))
</MACRO>
<MACRO>
<NAME>IS_GO_COLOR_GROUP</NAME>
#define IS_GO_COLOR_GROUP(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_COLOR_GROUP_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_color_group_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_color_group_find</NAME>
<RETURNS>GOColorGroup *</RETURNS>
char const *name, gpointer context
</FUNCTION>
<FUNCTION>
<NAME>go_color_group_fetch</NAME>
<RETURNS>GOColorGroup *</RETURNS>
char const *name, gpointer context
</FUNCTION>
<FUNCTION>
<NAME>go_color_group_add_color</NAME>
<RETURNS>void          </RETURNS>
GOColorGroup *cg, GOColor c
</FUNCTION>
<USER_FUNCTION>
<NAME>GOPaletteSwatchRenderCallback</NAME>
<RETURNS>void </RETURNS>
cairo_t *cr,
							 GdkRectangle const *area,
							 int index,
							 gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOPaletteSwatchTooltipCallback</NAME>
<RETURNS>const char *</RETURNS>
int index,
							 gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GO_TYPE_PALETTE</NAME>
#define GO_TYPE_PALETTE			(go_palette_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PALETTE</NAME>
#define GO_PALETTE(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GO_TYPE_PALETTE, GOPalette))
</MACRO>
<MACRO>
<NAME>GO_PALETTE_CLASS</NAME>
#define GO_PALETTE_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GO_TYPE_PALETTE, GOPaletteClass))
</MACRO>
<MACRO>
<NAME>GO_IS_PALETTE</NAME>
#define GO_IS_PALETTE(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GO_TYPE_PALETTE))
</MACRO>
<MACRO>
<NAME>GO_IS_PALETTE_CLASS</NAME>
#define GO_IS_PALETTE_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GO_TYPE_PALETTE))
</MACRO>
<MACRO>
<NAME>GO_PALETTE_GET_CLASS</NAME>
#define GO_PALETTE_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GO_TYPE_PALETTE, GOPaletteClass))
</MACRO>
<STRUCT>
<NAME>GOPalette</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPalettePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPaletteClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPalette</NAME>
struct _GOPalette
{
	GtkMenu parent;

	GOPalettePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GOPaletteClass</NAME>
struct _GOPaletteClass
{
	GtkMenuClass parent_class;	

	/* signals */
	void (*activate)		(GtkWidget *palette, int index);
	void (*automatic_activate)	(GtkWidget *palette, int index);
	void (*custom_activate)		(GtkWidget *palette);
};
</STRUCT>
<FUNCTION>
<NAME>go_palette_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_palette_new</NAME>
<RETURNS>GtkWidget 	*</RETURNS>
int n_swatches,double swatch_width,int n_columns,GOPaletteSwatchRenderCallback swatch_render,GOPaletteSwatchTooltipCallback get_tooltip,gpointer data,GDestroyNotify destroy
</FUNCTION>
<FUNCTION>
<NAME>go_palette_show_automatic</NAME>
<RETURNS>void 		 </RETURNS>
GOPalette *palette, int index, char const *label
</FUNCTION>
<FUNCTION>
<NAME>go_palette_show_custom</NAME>
<RETURNS>void 		 </RETURNS>
GOPalette *palette, char const *label
</FUNCTION>
<FUNCTION>
<NAME>go_palette_get_user_data</NAME>
<RETURNS>gpointer 	 </RETURNS>
GOPalette *palette
</FUNCTION>
<FUNCTION>
<NAME>go_palette_swatch_new</NAME>
<RETURNS>GtkWidget 	*</RETURNS>
GOPalette *palette, int index
</FUNCTION>
<FUNCTION>
<NAME>go_palette_get_n_swatches</NAME>
<RETURNS>int		 </RETURNS>
GOPalette *palette
</FUNCTION>
<MACRO>
<NAME>GO_MS_PARSER_STACK_TOP</NAME>
#define GO_MS_PARSER_STACK_TOP(stack) ((stack) ? (GOMSParserRecord *) (stack)->data : NULL)
</MACRO>
<MACRO>
<NAME>GO_MS_PARSER_STACK_SECOND</NAME>
#define GO_MS_PARSER_STACK_SECOND(stack) ((stack) && (stack)->next ? (GOMSParserRecord *) (stack)->next->data : NULL)
</MACRO>
<STRUCT>
<NAME>GOMSParserRecord</NAME>
typedef struct {
	guint16 opcode;
	guint8 vers;
	guint16 inst;
	guint32 length;
	guint32 length_remaining;
	gpointer parse_state;
	const GOMSParserRecordType *type;
} GOMSParserRecord;
</STRUCT>
<USER_FUNCTION>
<NAME>GOMSParserHandleAtom</NAME>
<RETURNS>void </RETURNS>
GOMSParserRecord *record, GSList *stack, const guint8 *data, GsfInput *input, GError **err, gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOMSParserStartContainer</NAME>
<RETURNS>void </RETURNS>
GSList *stack, GsfInput *input, GError **err, gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOMSParserEndContainer</NAME>
<RETURNS>void </RETURNS>
GSList *stack, GsfInput *input, GError **err, gpointer user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GOMSParserCallbacks</NAME>
typedef struct {
	GOMSParserHandleAtom handle_atom;
	GOMSParserStartContainer start_container;
	GOMSParserEndContainer end_container;
} GOMSParserCallbacks;
</STRUCT>
<FUNCTION>
<NAME>go_ms_parser_read</NAME>
<RETURNS>void </RETURNS>
GsfInput   *input,gsf_off_t   length,const GOMSParserRecordType *types,guint type_count,GOMSParserCallbacks *callbacks,gpointer user_data,GError    **err
</FUNCTION>
<FUNCTION>
<NAME>go_ms_parser_write</NAME>
<RETURNS>int             </RETURNS>
GODrawing  *drawing,GsfOutput  *output
</FUNCTION>
<STRUCT>
<NAME>GOApp</NAME>
</STRUCT>
<STRUCT>
<NAME>GODoc</NAME>
</STRUCT>
<STRUCT>
<NAME>GODocControl</NAME>
</STRUCT>
<STRUCT>
<NAME>GOCmdContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPlugin</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPluginService</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPluginLoader</NAME>
</STRUCT>
<STRUCT>
<NAME>ErrorInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GOFileSaver</NAME>
</STRUCT>
<STRUCT>
<NAME>GOFileOpener</NAME>
</STRUCT>
<STRUCT>
<NAME>IOContext</NAME>
</STRUCT>
<ENUM>
<NAME>FileProbeLevel</NAME>
typedef enum {
	FILE_PROBE_FILE_NAME,	/* Test only file name, don't read file contents */
	FILE_PROBE_CONTENT,	/* Read the whole file if it's necessary */
	FILE_PROBE_LAST
} FileProbeLevel;
</ENUM>
<STRUCT>
<NAME>error</NAME>
typedef struct {
	GTypeInterface base;

	char *  (*get_password)		(GOCmdContext *gcc,
					 char const *filename);
	void    (*set_sensitive)	(GOCmdContext *gcc,
					 gboolean sensitive);
	struct {
		void (*error)		(GOCmdContext *gcc, GError *err);
		void (*error_info)  	(GOCmdContext *gcc, ErrorInfo *err);
	} error;

</STRUCT>
<MACRO>
<NAME>GO_CMD_CONTEXT_CLASS</NAME>
#define GO_CMD_CONTEXT_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), GO_CMD_CONTEXT_TYPE, GOCmdContextClass))
</MACRO>
<MACRO>
<NAME>IS_GO_CMD_CONTEXT_CLASS</NAME>
#define IS_GO_CMD_CONTEXT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), GO_CMD_CONTEXT_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_cmd_context_progress_set</NAME>
<RETURNS>void  </RETURNS>
GOCmdContext *gcc, float f
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_progress_message_set</NAME>
<RETURNS>void  </RETURNS>
GOCmdContext *gcc, char const *msg
</FUNCTION>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_TYPE</NAME>
#define GO_PLUGIN_SERVICE_TYPE         (plugin_service_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE</NAME>
#define GO_PLUGIN_SERVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_TYPE, GOPluginService))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE</NAME>
#define IS_GO_PLUGIN_SERVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_GENERAL_TYPE</NAME>
#define GO_PLUGIN_SERVICE_GENERAL_TYPE  (plugin_service_general_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_GENERAL</NAME>
#define GO_PLUGIN_SERVICE_GENERAL(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_GENERAL_TYPE, PluginServiceGeneral))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE_GENERAL</NAME>
#define IS_GO_PLUGIN_SERVICE_GENERAL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_GENERAL_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_general_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PluginServiceGeneral</NAME>
</STRUCT>
<STRUCT>
<NAME>PluginServiceGeneralCallbacks</NAME>
typedef struct {
	void (*plugin_func_init) (GOPluginService *service, ErrorInfo **ret_error);
	void (*plugin_func_cleanup) (GOPluginService *service, ErrorInfo **ret_error);
} PluginServiceGeneralCallbacks;
</STRUCT>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_FILE_OPENER_TYPE</NAME>
#define GO_PLUGIN_SERVICE_FILE_OPENER_TYPE  (plugin_service_file_opener_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_FILE_OPENER</NAME>
#define GO_PLUGIN_SERVICE_FILE_OPENER(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_FILE_OPENER_TYPE, PluginServiceFileOpener))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE_FILE_OPENER</NAME>
#define IS_GO_PLUGIN_SERVICE_FILE_OPENER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_FILE_OPENER_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_file_opener_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PluginServiceFileOpener</NAME>
</STRUCT>
<STRUCT>
<NAME>PluginServiceFileOpenerCallbacks</NAME>
typedef struct {
	/* plugin_func_file_probe may be NULL */
	gboolean (*plugin_func_file_probe) (
	         GOFileOpener const *fo, GOPluginService *service,
	         GsfInput *input, FileProbeLevel pl);
	void     (*plugin_func_file_open) (
	         GOFileOpener const *fo, GOPluginService *service,
	         IOContext *io_context, gpointer fixme_workbook_view,
		 GsfInput *input);
} PluginServiceFileOpenerCallbacks;
</STRUCT>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_FILE_SAVER_TYPE</NAME>
#define GO_PLUGIN_SERVICE_FILE_SAVER_TYPE  (plugin_service_file_saver_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_FILE_SAVER</NAME>
#define GO_PLUGIN_SERVICE_FILE_SAVER(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_FILE_SAVER_TYPE, PluginServiceFileSaver))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE_FILE_SAVER</NAME>
#define IS_GO_PLUGIN_SERVICE_FILE_SAVER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_FILE_SAVER_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_file_saver_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PluginServiceFileSaver</NAME>
</STRUCT>
<STRUCT>
<NAME>PluginServiceFileSaverCallbacks</NAME>
typedef struct {
	void  (*plugin_func_file_save) (
	      GOFileSaver const *fs, GOPluginService *service,
	      IOContext *io_context, gconstpointer fixme_workbook_view,
	      GsfOutput *output);
} PluginServiceFileSaverCallbacks;
</STRUCT>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_PLUGIN_LOADER_TYPE</NAME>
#define GO_PLUGIN_SERVICE_PLUGIN_LOADER_TYPE  (plugin_service_plugin_loader_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_PLUGIN_LOADER</NAME>
#define GO_PLUGIN_SERVICE_PLUGIN_LOADER(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_PLUGIN_LOADER_TYPE, PluginServicePluginLoader))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE_PLUGIN_LOADER</NAME>
#define IS_GO_PLUGIN_SERVICE_PLUGIN_LOADER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_PLUGIN_LOADER_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_plugin_loader_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PluginServicePluginLoader</NAME>
</STRUCT>
<STRUCT>
<NAME>PluginServicePluginLoaderCallbacks</NAME>
typedef struct {
	GType (*plugin_func_get_loader_type) (
	      GOPluginService *service, ErrorInfo **ret_error);
} PluginServicePluginLoaderCallbacks;
</STRUCT>
<FUNCTION>
<NAME>plugin_service_plugin_loader_generate_type</NAME>
<RETURNS>GType </RETURNS>
GOPluginService *service,ErrorInfo **ret_error
</FUNCTION>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_GOBJECT_LOADER_TYPE</NAME>
#define GO_PLUGIN_SERVICE_GOBJECT_LOADER_TYPE  (plugin_service_gobject_loader_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_GOBJECT_LOADER</NAME>
#define GO_PLUGIN_SERVICE_GOBJECT_LOADER(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_GOBJECT_LOADER_TYPE, PluginServiceGObjectLoader))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE_GOBJECT_LOADER</NAME>
#define IS_GO_PLUGIN_SERVICE_GOBJECT_LOADER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_GOBJECT_LOADER_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_gobject_loader_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PluginServiceGObjectLoader</NAME>
</STRUCT>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_SIMPLE_TYPE</NAME>
#define GO_PLUGIN_SERVICE_SIMPLE_TYPE  (plugin_service_simple_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_SERVICE_SIMPLE</NAME>
#define GO_PLUGIN_SERVICE_SIMPLE(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_SERVICE_SIMPLE_TYPE, PluginServiceSimple))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_SERVICE_SIMPLE</NAME>
#define IS_GO_PLUGIN_SERVICE_SIMPLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_SERVICE_SIMPLE_TYPE))
</MACRO>
<FUNCTION>
<NAME>plugin_service_simple_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>PluginServiceSimple</NAME>
</STRUCT>
<FUNCTION>
<NAME>plugin_service_new</NAME>
<RETURNS>GOPluginService  *</RETURNS>
GOPlugin *plugin, xmlNode *tree, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_get_id</NAME>
<RETURNS>char const     *</RETURNS>
const GOPluginService *service
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_get_description</NAME>
<RETURNS>char const     *</RETURNS>
GOPluginService *service
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_get_plugin</NAME>
<RETURNS>GOPlugin      *</RETURNS>
GOPluginService *service
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_get_cbs</NAME>
<RETURNS>gpointer	</RETURNS>
GOPluginService *service
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_activate</NAME>
<RETURNS>void		</RETURNS>
GOPluginService *service, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_deactivate</NAME>
<RETURNS>void		</RETURNS>
GOPluginService *service, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_load</NAME>
<RETURNS>void		</RETURNS>
GOPluginService *service, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_unload</NAME>
<RETURNS>void		</RETURNS>
GOPluginService *service, ErrorInfo **ret_error
</FUNCTION>
<USER_FUNCTION>
<NAME>GOPluginServiceCreate</NAME>
<RETURNS>GType </RETURNS>
void
</USER_FUNCTION>
<FUNCTION>
<NAME>plugin_services_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>plugin_services_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>plugin_service_define</NAME>
<RETURNS>void </RETURNS>
char const *type_str,GOPluginServiceCreate ctor
</FUNCTION>
<STRUCT>
<NAME>GOService</NAME>
struct _GOService {
	GObject base;
	GOPlugin *plugin;
};
</STRUCT>
<STRUCT>
<NAME>GOServiceClass</NAME>
typedef struct {
	GObjectClass base;
	GOErrorStack *(*read_details) (GOService *service, xmlNode *tree);
	GOErrorStack *(*activate)     (GOService *service);
	GOErrorStack *(*deactivate)   (GOService *service);
	char 	     *(*description)  (GOService *service);
} GOServiceClass;
</STRUCT>
<STRUCT>
<NAME>GOServiceSimple</NAME>
struct _GOServiceSimple {
	GOService	base;
};
</STRUCT>
<TYPEDEF>
<NAME>GOServiceSimpleClass</NAME>
typedef GOServiceClass GOServiceSimpleClass;
</TYPEDEF>
<MACRO>
<NAME>GO_DOC_TYPE</NAME>
#define GO_DOC_TYPE	    (go_doc_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DOC</NAME>
#define GO_DOC(o)	    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DOC_TYPE, GODoc))
</MACRO>
<MACRO>
<NAME>IS_GO_DOC</NAME>
#define IS_GO_DOC(o)	    (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DOC_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_doc_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_doc_is_pristine</NAME>
<RETURNS>gboolean </RETURNS>
GODoc const *doc
</FUNCTION>
<FUNCTION>
<NAME>go_doc_set_dirty</NAME>
<RETURNS>void	 </RETURNS>
GODoc *doc, gboolean is_dirty
</FUNCTION>
<FUNCTION>
<NAME>go_doc_is_dirty</NAME>
<RETURNS>gboolean </RETURNS>
GODoc const *doc
</FUNCTION>
<FUNCTION>
<NAME>go_doc_set_uri</NAME>
<RETURNS>gboolean	 </RETURNS>
GODoc *doc, char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_doc_get_uri</NAME>
<RETURNS>char const	*</RETURNS>
GODoc const *doc
</FUNCTION>
<FUNCTION>
<NAME>go_doc_get_meta_data</NAME>
<RETURNS>GsfDocMetaData	*</RETURNS>
GODoc const *doc
</FUNCTION>
<FUNCTION>
<NAME>go_doc_set_meta_data</NAME>
<RETURNS>void		 </RETURNS>
GODoc *doc, GsfDocMetaData *data
</FUNCTION>
<FUNCTION>
<NAME>go_doc_update_meta_data</NAME>
<RETURNS>void		 </RETURNS>
GODoc *doc
</FUNCTION>
<FUNCTION>
<NAME>go_doc_new_from_input</NAME>
<RETURNS>GODoc   *</RETURNS>
GsfInput *input,GODocImporter const *fmt,GOIOContext *context,gchar const *encoding
</FUNCTION>
<FUNCTION>
<NAME>go_doc_new_from_uri</NAME>
<RETURNS>GODoc   *</RETURNS>
char const *uri,GnmFileOpener const *fmt,GOIOContext *context,gchar const *encoding
</FUNCTION>
<FUNCTION>
<NAME>go_doc_save</NAME>
<RETURNS>gboolean </RETURNS>
GODoc *doc, GOIOContext *context
</FUNCTION>
<FUNCTION>
<NAME>go_doc_save_as</NAME>
<RETURNS>gboolean </RETURNS>
GODoc *doc, GODocExporter *fmt, char const *uri,GOIOContext *cc
</FUNCTION>
<FUNCTION>
<NAME>go_doc_sendto</NAME>
<RETURNS>gboolean </RETURNS>
GODoc *doc, GOIOContext *cc
</FUNCTION>
<STRUCT>
<NAME>GOPluginService</NAME>
struct _GOPluginService {
	GObject   g_object;

	char   *id;
	GOPlugin *plugin;
	gboolean is_loaded;

	/* protected */
	gpointer cbs_ptr;
	gboolean is_active;

	/* private */
	char *saved_description;
};
</STRUCT>
<STRUCT>
<NAME>GOPluginServiceClass</NAME>
typedef struct{
	GObjectClass g_object_class;

	void (*read_xml) (GOPluginService *service, xmlNode *tree, ErrorInfo **ret_error);
	void (*activate) (GOPluginService *service, ErrorInfo **ret_error);
	void (*deactivate) (GOPluginService *service, ErrorInfo **ret_error);
	char *(*get_description) (GOPluginService *service);
} GOPluginServiceClass;
</STRUCT>
<MACRO>
<NAME>GPS_CLASS</NAME>
#define GPS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GO_PLUGIN_SERVICE_TYPE, GOPluginServiceClass))
</MACRO>
<MACRO>
<NAME>GPS_GET_CLASS</NAME>
#define GPS_GET_CLASS(o) GPS_CLASS (G_OBJECT_GET_CLASS (o))
</MACRO>
<STRUCT>
<NAME>PluginServiceGObjectLoaderClass</NAME>
typedef struct{
	GOPluginServiceClass plugin_service_class;
	GHashTable *pending; /* has service instances by type names */
} PluginServiceGObjectLoaderClass;
</STRUCT>
<STRUCT>
<NAME>PluginServiceGObjectLoader</NAME>
struct _PluginServiceGObjectLoader {
	GOPluginService plugin_service;
};
</STRUCT>
<MACRO>
<NAME>GPS_GOBJECT_LOADER_CLASS</NAME>
#define GPS_GOBJECT_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GO_PLUGIN_SERVICE_TYPE, PluginServiceGObjectLoaderClass))
</MACRO>
<MACRO>
<NAME>GPS_GOBJECT_LOADER_GET_CLASS</NAME>
#define GPS_GOBJECT_LOADER_GET_CLASS(o) GPS_GOBJECT_LOADER_CLASS (G_OBJECT_GET_CLASS (o))
</MACRO>
<STRUCT>
<NAME>PluginServiceSimpleClass</NAME>
typedef struct{
	GOPluginServiceClass plugin_service_class;
} PluginServiceSimpleClass;
</STRUCT>
<STRUCT>
<NAME>PluginServiceSimple</NAME>
struct _PluginServiceSimple {
	GOPluginService plugin_service;
};
</STRUCT>
<MACRO>
<NAME>GO_DOC_CONTROL_TYPE</NAME>
#define GO_DOC_CONTROL_TYPE	    (go_doc_control_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DOC_CONTROL</NAME>
#define GO_DOC_CONTROL(o)	    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DOC_CONTROL_TYPE, GODocControl))
</MACRO>
<MACRO>
<NAME>IS_GO_DOC_CONTROL</NAME>
#define IS_GO_DOC_CONTROL(o)	    (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DOC_CONTROL_TYPE))
</MACRO>
<ENUM>
<NAME>GODocControlState</NAME>
typedef enum {
	GO_DOC_CONTROL_STATE_NORMAL = 0,
	GO_DOC_CONTROL_STATE_FULLSCREEN,
	GO_DOC_CONTROL_STATE_MAX
} GODocControlState;
</ENUM>
<FUNCTION>
<NAME>go_doc_control_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>IOContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>TYPE_IO_CONTEXT</NAME>
#define TYPE_IO_CONTEXT    (io_context_get_type ())
</MACRO>
<MACRO>
<NAME>IO_CONTEXT</NAME>
#define IO_CONTEXT(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IO_CONTEXT, IOContext))
</MACRO>
<MACRO>
<NAME>IS_IO_CONTEXT</NAME>
#define IS_IO_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IO_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>io_context_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_context_new</NAME>
<RETURNS>IOContext *</RETURNS>
GOCmdContext *cc
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_unknown</NAME>
<RETURNS>void       </RETURNS>
IOContext *ioc
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_info_set</NAME>
<RETURNS>void       </RETURNS>
IOContext *ioc, ErrorInfo *error
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_string</NAME>
<RETURNS>void       </RETURNS>
IOContext *ioc, const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_push</NAME>
<RETURNS>void       </RETURNS>
IOContext *ioc, ErrorInfo *error
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_clear</NAME>
<RETURNS>void       </RETURNS>
IOContext *ioc
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_display</NAME>
<RETURNS>void       </RETURNS>
IOContext *ioc
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_error_occurred</NAME>
<RETURNS>gboolean   </RETURNS>
IOContext *ioc
</FUNCTION>
<FUNCTION>
<NAME>gnumeric_io_warning_occurred</NAME>
<RETURNS>gboolean   </RETURNS>
IOContext *ioc
</FUNCTION>
<FUNCTION>
<NAME>io_progress_message</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, const gchar *msg
</FUNCTION>
<FUNCTION>
<NAME>io_progress_update</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, gdouble f
</FUNCTION>
<FUNCTION>
<NAME>io_progress_range_push</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, gdouble min, gdouble max
</FUNCTION>
<FUNCTION>
<NAME>io_progress_range_pop</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context
</FUNCTION>
<FUNCTION>
<NAME>count_io_progress_set</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, gint total, gint step
</FUNCTION>
<FUNCTION>
<NAME>count_io_progress_update</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, gint inc
</FUNCTION>
<FUNCTION>
<NAME>value_io_progress_set</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, gint total, gint step
</FUNCTION>
<FUNCTION>
<NAME>value_io_progress_update</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context, gint value
</FUNCTION>
<FUNCTION>
<NAME>io_progress_unset</NAME>
<RETURNS>void       </RETURNS>
IOContext *io_context
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_context_set_num_files</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, guint count
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_context_processing_file</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, char const *uri
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_warning</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, char const *fmt, ...
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_warning_varargs</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, char const *fmt, va_list args
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_warning_unknown_font</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, char const *font_name
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_warning_unknown_function</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, char const *funct_name
</FUNCTION>
<FUNCTION>
<NAME>gnm_io_warning_unsupported_feature</NAME>
<RETURNS>void </RETURNS>
IOContext *ioc, char const *feature
</FUNCTION>
<STRUCT>
<NAME>GOPluginModuleDepend</NAME>
typedef struct {
	char const * const key;		/* object being versioned */
	char const * const version;	/* version id (strict equality is required) */
} GOPluginModuleDepend;
</STRUCT>
<STRUCT>
<NAME>GOPluginModuleHeader</NAME>
typedef struct {
	guint32 const magic_number;
	guint32 const num_depends;
} GOPluginModuleHeader;
</STRUCT>
<MACRO>
<NAME>GOFFICE_API_VERSION</NAME>
#define GOFFICE_API_VERSION		"0.0"
</MACRO>
<MACRO>
<NAME>GOFFICE_MODULE_PLUGIN_MAGIC_NUMBER</NAME>
#define GOFFICE_MODULE_PLUGIN_MAGIC_NUMBER             0x476e756d
</MACRO>
<MACRO>
<NAME>GOFFICE_PLUGIN_MODULE_HEADER</NAME>
#define GOFFICE_PLUGIN_MODULE_HEADER 					\
G_MODULE_EXPORT GOPluginModuleDepend const go_plugin_depends [] = {	\
    { "goffice", GOFFICE_API_VERSION }					\
};	\
G_MODULE_EXPORT GOPluginModuleHeader const go_plugin_header =  		\
	{ GOFFICE_MODULE_PLUGIN_MAGIC_NUMBER, G_N_ELEMENTS (go_plugin_depends) }
</MACRO>
<FUNCTION>
<NAME>go_plugin_init</NAME>
<RETURNS>void </RETURNS>
GOPlugin *plugin, GOCmdContext *cc
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_shutdown</NAME>
<RETURNS>void </RETURNS>
GOPlugin *plugin, GOCmdContext *cc
</FUNCTION>
<MACRO>
<NAME>GO_APP_TYPE</NAME>
#define GO_APP_TYPE	    (go_app_get_type ())
</MACRO>
<MACRO>
<NAME>GO_APP</NAME>
#define GO_APP(o)	    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_APP_TYPE, GOApp))
</MACRO>
<MACRO>
<NAME>IS_GO_APP</NAME>
#define IS_GO_APP(o)	    (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_APP_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_app_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_app_get_plugin</NAME>
<RETURNS>GOPlugin *</RETURNS>
char const *id
</FUNCTION>
<FUNCTION>
<NAME>go_app_sys_lib_dir</NAME>
<RETURNS>char	 *</RETURNS>
GOApp const *app, char const *subdir
</FUNCTION>
<FUNCTION>
<NAME>go_app_sys_data_dir</NAME>
<RETURNS>char	 *</RETURNS>
GOApp const *app, char const *subdir
</FUNCTION>
<FUNCTION>
<NAME>go_app_sys_plugin_dir</NAME>
<RETURNS>char	 *</RETURNS>
GOApp const *app
</FUNCTION>
<FUNCTION>
<NAME>go_app_sys_glade_dir</NAME>
<RETURNS>char	 *</RETURNS>
GOApp const *app
</FUNCTION>
<ENUM>
<NAME>FileFormatLevel</NAME>
typedef enum {
	FILE_FL_NONE,            /* No name assigned, won't happen */
	FILE_FL_WRITE_ONLY,      /* PostScript etc, won't be remembered */
	FILE_FL_NEW,             /* Wb just created */
	FILE_FL_MANUAL,          /* Save gets punted to save as */
	FILE_FL_MANUAL_REMEMBER, /* Ditto, but remember in history */
	FILE_FL_AUTO,            /* Save will save to this filename */
	FILE_FL_LAST
} FileFormatLevel;
</ENUM>
<FUNCTION>
<NAME>go_file_saver_level_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GO_FILE_SAVER_LEVEL_TYPE</NAME>
#define GO_FILE_SAVER_LEVEL_TYPE (go_file_saver_level_get_type ())
</MACRO>
<ENUM>
<NAME>FileSaveScope</NAME>
typedef enum {
	FILE_SAVE_WORKBOOK,
	FILE_SAVE_SHEET,
	FILE_SAVE_RANGE,
	FILE_SAVE_LAST
} FileSaveScope;
</ENUM>
<FUNCTION>
<NAME>go_file_saver_scope_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GO_FILE_SAVER_SCOPE_TYPE</NAME>
#define GO_FILE_SAVER_SCOPE_TYPE (go_file_saver_scope_get_type ())
</MACRO>
<STRUCT>
<NAME>GOFileOpenerClass</NAME>
</STRUCT>
<MACRO>
<NAME>TYPE_GO_FILE_OPENER</NAME>
#define TYPE_GO_FILE_OPENER             (go_file_opener_get_type ())
</MACRO>
<MACRO>
<NAME>GO_FILE_OPENER</NAME>
#define GO_FILE_OPENER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GO_FILE_OPENER, GOFileOpener))
</MACRO>
<MACRO>
<NAME>IS_GO_FILE_OPENER</NAME>
#define IS_GO_FILE_OPENER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GO_FILE_OPENER))
</MACRO>
<USER_FUNCTION>
<NAME>GOFileOpenerProbeFunc</NAME>
<RETURNS>gboolean </RETURNS>
GOFileOpener const *fo,
					    GsfInput *input,
					    FileProbeLevel pl
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOFileOpenerOpenFunc</NAME>
<RETURNS>void </RETURNS>
GOFileOpener const *fo,
					  IOContext *io_context,
					  gpointer FIXME_FIXME_workbook_view,
					  GsfInput *input
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOFileOpenerOpenFuncWithEnc</NAME>
<RETURNS>void </RETURNS>
GOFileOpener const *fo,
						 gchar const *enc,
						 IOContext *io_context,
						 gpointer FIXME_workbook_view,
						 GsfInput *input
</USER_FUNCTION>
<FUNCTION>
<NAME>go_file_opener_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_new</NAME>
<RETURNS>GOFileOpener *</RETURNS>
char const *id,char const *description,GSList *suffixes,GSList *mimes,GOFileOpenerProbeFunc probe_func,GOFileOpenerOpenFunc open_func
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_new_with_enc</NAME>
<RETURNS>GOFileOpener *</RETURNS>
char const *id,char const *description,GSList *suffixes,GSList *mimes,GOFileOpenerProbeFunc probe_func,GOFileOpenerOpenFuncWithEnc open_func
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_probe</NAME>
<RETURNS>gboolean     </RETURNS>
GOFileOpener const *fo, GsfInput *input,FileProbeLevel pl
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_open</NAME>
<RETURNS>void         </RETURNS>
GOFileOpener const *fo, gchar const *opt_enc,IOContext *io_context,gpointer FIXME_workbook_view,GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_get_id</NAME>
<RETURNS>char const *</RETURNS>
GOFileOpener const *fo
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_get_description</NAME>
<RETURNS>char const *</RETURNS>
GOFileOpener const *fo
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_is_encoding_dependent</NAME>
<RETURNS>gboolean    </RETURNS>
GOFileOpener const *fo
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_can_probe</NAME>
<RETURNS>gboolean    </RETURNS>
GOFileOpener const *fo,FileProbeLevel pl
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_get_suffixes</NAME>
<RETURNS>GSList const *</RETURNS>
GOFileOpener const *fo
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_get_mimes</NAME>
<RETURNS>GSList const *</RETURNS>
GOFileOpener const *fo
</FUNCTION>
<STRUCT>
<NAME>GOFileSaverClass</NAME>
</STRUCT>
<MACRO>
<NAME>TYPE_GO_FILE_SAVER</NAME>
#define TYPE_GO_FILE_SAVER             (go_file_saver_get_type ())
</MACRO>
<MACRO>
<NAME>GO_FILE_SAVER</NAME>
#define GO_FILE_SAVER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GO_FILE_SAVER, GOFileSaver))
</MACRO>
<MACRO>
<NAME>IS_GO_FILE_SAVER</NAME>
#define IS_GO_FILE_SAVER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GO_FILE_SAVER))
</MACRO>
<USER_FUNCTION>
<NAME>GOFileSaverSaveFunc</NAME>
<RETURNS>void </RETURNS>
GOFileSaver const *fs,
				     IOContext *io_context,
				     gconstpointer FIXME_FIXME_workbook_view,
				     GsfOutput *output
</USER_FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_new</NAME>
<RETURNS>GOFileSaver *</RETURNS>
char const *id,char const *extension,char const *description,FileFormatLevel level,GOFileSaverSaveFunc save_func
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_set_save_scope</NAME>
<RETURNS>void          </RETURNS>
GOFileSaver *fs, FileSaveScope scope
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_save_scope</NAME>
<RETURNS>FileSaveScope </RETURNS>
GOFileSaver const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_set_export_options</NAME>
<RETURNS>gboolean     </RETURNS>
GOFileSaver *fs,GODoc *doc,const char *options,GError **err
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_save</NAME>
<RETURNS>void         </RETURNS>
GOFileSaver const *fs, IOContext *io_context,gconstpointer FIXME_workbook_view,GsfOutput *output
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_set_overwrite_files</NAME>
<RETURNS>void         </RETURNS>
GOFileSaver *fs,gboolean overwrite
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_id</NAME>
<RETURNS>char const *</RETURNS>
GOFileSaver const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_extension</NAME>
<RETURNS>char const *</RETURNS>
GOFileSaver const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_mime_type</NAME>
<RETURNS>char const *</RETURNS>
GOFileSaver const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_description</NAME>
<RETURNS>char const *</RETURNS>
GOFileSaver const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_format_level</NAME>
<RETURNS>FileFormatLevel </RETURNS>
GOFileSaver const *fs
</FUNCTION>
<FUNCTION>
<NAME>go_get_file_openers</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_unregister</NAME>
<RETURNS>void		 </RETURNS>
GOFileOpener *fo
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_register</NAME>
<RETURNS>void		 </RETURNS>
GOFileOpener *fo, gint priority
</FUNCTION>
<FUNCTION>
<NAME>go_file_opener_for_id</NAME>
<RETURNS>GOFileOpener	*</RETURNS>
char const *id
</FUNCTION>
<FUNCTION>
<NAME>go_get_file_savers</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_unregister</NAME>
<RETURNS>void </RETURNS>
GOFileSaver *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_register</NAME>
<RETURNS>void </RETURNS>
GOFileSaver *fs
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_register_as_default</NAME>
<RETURNS>void </RETURNS>
GOFileSaver *fs, gint priority
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_get_default</NAME>
<RETURNS>GOFileSaver	*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_for_mime_type</NAME>
<RETURNS>GOFileSaver	*</RETURNS>
char const *mime_type
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_for_file_name</NAME>
<RETURNS>GOFileSaver	*</RETURNS>
char const *file_name
</FUNCTION>
<FUNCTION>
<NAME>go_file_saver_for_id</NAME>
<RETURNS>GOFileSaver	*</RETURNS>
char const *id
</FUNCTION>
<STRUCT>
<NAME>GODoc</NAME>
struct _GODoc {
	GObject		 base;

	gchar		*uri;
	GsfDocMetaData	*meta_data;
	gboolean	 modified;
	gboolean	 pristine;
};
</STRUCT>
<STRUCT>
<NAME>GODocClass</NAME>
typedef struct {
	GObjectClass	base;

	struct {
		/* Reload doc statistics and update linked values */
		void (*update)  (GODoc *doc);
		void (*changed) (GODoc *doc);
	} meta_data;
} GODocClass;
</STRUCT>
<MACRO>
<NAME>GO_DOC_CLASS</NAME>
#define GO_DOC_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GO_DOC_TYPE, GODocClass))
</MACRO>
<MACRO>
<NAME>IS_GO_DOC_CLASS</NAME>
#define IS_GO_DOC_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GO_DOC_TYPE))
</MACRO>
<MACRO>
<NAME>GO_DOC_GET_CLASS</NAME>
#define GO_DOC_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GO_DOC_TYPE, GODocClass))
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_LOADER_MODULE_TYPE</NAME>
#define GO_PLUGIN_LOADER_MODULE_TYPE		(go_plugin_loader_module_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_LOADER_MODULE</NAME>
#define GO_PLUGIN_LOADER_MODULE(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_LOADER_MODULE_TYPE, GOPluginLoaderModule))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_LOADER_MODULE</NAME>
#define IS_GO_PLUGIN_LOADER_MODULE(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_LOADER_MODULE_TYPE))
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_LOADER_MODULE_CLASS</NAME>
#define GO_PLUGIN_LOADER_MODULE_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GO_PLUGIN_LOADER_MODULE_TYPE, GOPluginLoaderModuleClass))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_LOADER_MODULE_CLASS</NAME>
#define IS_GO_PLUGIN_LOADER_MODULE_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GO_PLUGIN_LOADER_MODULE_TYPE))
</MACRO>
<STRUCT>
<NAME>GOPluginLoaderModule</NAME>
typedef struct {
	GObject	base;

	gchar *module_file_name;
	GModule *handle;

	void (*plugin_init)	(GOPlugin *plugin, GOCmdContext *cc);
	void (*plugin_shutdown) (GOPlugin *plugin, GOCmdContext *cc);
} GOPluginLoaderModule;
</STRUCT>
<TYPEDEF>
<NAME>GOPluginLoaderModuleClass</NAME>
typedef GObjectClass GOPluginLoaderModuleClass;
</TYPEDEF>
<FUNCTION>
<NAME>go_plugin_loader_module_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_module_register_version</NAME>
<RETURNS>void </RETURNS>
char const *id, char const *ver
</FUNCTION>
<FUNCTION>
<NAME>go_error_stack_new</NAME>
<RETURNS>GOErrorStack *</RETURNS>
GOErrorStack *parent,char const *fmt, ...
</FUNCTION>
<FUNCTION>
<NAME>go_error_stack_add_child</NAME>
<RETURNS>void </RETURNS>
GOErrorStack *estack, GOErrorStack *child
</FUNCTION>
<FUNCTION>
<NAME>go_error_stack_dump</NAME>
<RETURNS>void </RETURNS>
GOErrorStack *estack
</FUNCTION>
<FUNCTION>
<NAME>go_error_stack_free</NAME>
<RETURNS>void </RETURNS>
GOErrorStack *estack
</FUNCTION>
<MACRO>
<NAME>GO_CMD_CONTEXT_TYPE</NAME>
#define GO_CMD_CONTEXT_TYPE        (go_cmd_context_get_type ())
</MACRO>
<MACRO>
<NAME>GO_CMD_CONTEXT</NAME>
#define GO_CMD_CONTEXT(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_CMD_CONTEXT_TYPE, GOCmdContext))
</MACRO>
<MACRO>
<NAME>IS_GO_CMD_CONTEXT</NAME>
#define IS_GO_CMD_CONTEXT(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_CMD_CONTEXT_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_cmd_context_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_error</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc, GError *err
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_get_password</NAME>
<RETURNS>char  *</RETURNS>
GOCmdContext *cc, char const *fname
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_set_sensitive</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc, gboolean flag
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_error_system</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc, char const *msg
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_error_import</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc, char const *msg
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_error_export</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc, char const *msg
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_error_invalid</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc,char const *msg, char const *val
</FUNCTION>
<FUNCTION>
<NAME>go_cmd_context_error_info</NAME>
<RETURNS>void   </RETURNS>
GOCmdContext *cc, ErrorInfo *stack
</FUNCTION>
<FUNCTION>
<NAME>go_error_system</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_error_import</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_error_export</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_error_invalid</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_object_new</NAME>
<RETURNS>gpointer </RETURNS>
char const *type, char const *first_prop, ...
</FUNCTION>
<FUNCTION>
<NAME>go_object_new_valist</NAME>
<RETURNS>gpointer </RETURNS>
char const *type, char const *first_prop,va_list vargs
</FUNCTION>
<MACRO>
<NAME>GO_SERVICE_OBJECT_TYPE</NAME>
#define GO_SERVICE_OBJECT_TYPE  (go_service_object_get_type ())
</MACRO>
<MACRO>
<NAME>GO_SERVICE_OBJECT</NAME>
#define GO_SERVICE_OBJECT(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_SERVICE_OBJECT_TYPE, GOServiceObject))
</MACRO>
<MACRO>
<NAME>IS_GO_SERVICE_OBJECT</NAME>
#define IS_GO_SERVICE_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_SERVICE_OBJECT_TYPE))
</MACRO>
<STRUCT>
<NAME>GOServiceObject</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_service_object_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_service_object_primary_type</NAME>
<RETURNS>char const   *</RETURNS>
GOServiceObject const *service
</FUNCTION>
<FUNCTION>
<NAME>go_service_object_interfaces</NAME>
<RETURNS>GSList const *</RETURNS>
GOServiceObject const *service
</FUNCTION>
<MACRO>
<NAME>GO_SERVICE_TYPE</NAME>
#define GO_SERVICE_TYPE         (go_service_get_type ())
</MACRO>
<MACRO>
<NAME>GO_SERVICE</NAME>
#define GO_SERVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_SERVICE_TYPE, GOService))
</MACRO>
<MACRO>
<NAME>IS_GO_SERVICE</NAME>
#define IS_GO_SERVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_SERVICE_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_service_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_service_get_plugin</NAME>
<RETURNS>GOPlugin *</RETURNS>
GOService const *service
</FUNCTION>
<MACRO>
<NAME>GO_SERVICE_SIMPLE_TYPE</NAME>
#define GO_SERVICE_SIMPLE_TYPE	(go_service_simple_get_type ())
</MACRO>
<MACRO>
<NAME>GO_SERVICE_SIMPLE</NAME>
#define GO_SERVICE_SIMPLE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_SERVICE_SIMPLE_TYPE, GOServiceSimple))
</MACRO>
<MACRO>
<NAME>IS_GO_SERVICE_SIMPLE</NAME>
#define IS_GO_SERVICE_SIMPLE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_SERVICE_SIMPLE_TYPE))
</MACRO>
<STRUCT>
<NAME>GOServiceSimple</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_service_simple_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GODocControl</NAME>
struct _GODocControl {
	GObject		 base;

	struct {
		gpointer dummy;
	} state[GO_DOC_CONTROL_STATE_MAX];
};
</STRUCT>
<STRUCT>
<NAME>GODocControlClass</NAME>
typedef struct {
	GObjectClass	base;
} GODocControlClass;
</STRUCT>
<MACRO>
<NAME>GO_DOC_CONTROL_CLASS</NAME>
#define GO_DOC_CONTROL_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k),   GO_DOC_CONTROL_TYPE, GODocControlClass))
</MACRO>
<MACRO>
<NAME>IS_GO_DOC_CONTROL_CLASS</NAME>
#define IS_GO_DOC_CONTROL_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k),   GO_DOC_CONTROL_TYPE))
</MACRO>
<MACRO>
<NAME>GO_DOC_CONTROL_GET_CLASS</NAME>
#define GO_DOC_CONTROL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GO_DOC_CONTROL_TYPE, GODocControlClass))
</MACRO>
<ENUM>
<NAME>GOSeverity</NAME>
typedef enum {
	GO_WARNING = 1,
	GO_ERROR
} GOSeverity;
</ENUM>
<FUNCTION>
<NAME>error_info_new_str</NAME>
<RETURNS>ErrorInfo *</RETURNS>
char const *msg
</FUNCTION>
<FUNCTION>
<NAME>error_info_new_printf</NAME>
<RETURNS>ErrorInfo *</RETURNS>
char const *msg_format, ...
</FUNCTION>
<FUNCTION>
<NAME>error_info_new_vprintf</NAME>
<RETURNS>ErrorInfo *</RETURNS>
GOSeverity severity,char const *msg_format,va_list args
</FUNCTION>
<FUNCTION>
<NAME>error_info_new_str_with_details</NAME>
<RETURNS>ErrorInfo *</RETURNS>
char const *msg, ErrorInfo *details
</FUNCTION>
<FUNCTION>
<NAME>error_info_new_str_with_details_list</NAME>
<RETURNS>ErrorInfo *</RETURNS>
char const *msg, GSList *details
</FUNCTION>
<FUNCTION>
<NAME>error_info_new_from_error_list</NAME>
<RETURNS>ErrorInfo *</RETURNS>
GSList *errors
</FUNCTION>
<FUNCTION>
<NAME>error_info_new_from_errno</NAME>
<RETURNS>ErrorInfo *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>error_info_add_details</NAME>
<RETURNS>void	   </RETURNS>
ErrorInfo *error, ErrorInfo *details
</FUNCTION>
<FUNCTION>
<NAME>error_info_add_details_list</NAME>
<RETURNS>void	   </RETURNS>
ErrorInfo *error, GSList *details
</FUNCTION>
<FUNCTION>
<NAME>error_info_free</NAME>
<RETURNS>void	   </RETURNS>
ErrorInfo *error
</FUNCTION>
<FUNCTION>
<NAME>error_info_print</NAME>
<RETURNS>void	   </RETURNS>
ErrorInfo *error
</FUNCTION>
<FUNCTION>
<NAME>error_info_peek_message</NAME>
<RETURNS>char const*</RETURNS>
ErrorInfo *error
</FUNCTION>
<FUNCTION>
<NAME>error_info_peek_details</NAME>
<RETURNS>GSList	  *</RETURNS>
ErrorInfo *error
</FUNCTION>
<FUNCTION>
<NAME>error_info_peek_severity</NAME>
<RETURNS>GOSeverity </RETURNS>
ErrorInfo *error
</FUNCTION>
<MACRO>
<NAME>GO_INIT_RET_ERROR_INFO</NAME>
#define GO_INIT_RET_ERROR_INFO(ret_error) \
G_STMT_START { \
	g_assert (ret_error != NULL); \
	*ret_error = NULL; \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>GO_FILE_OPENER_CLASS</NAME>
#define GO_FILE_OPENER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GO_FILE_OPENER, GOFileOpenerClass))
</MACRO>
<MACRO>
<NAME>GO_FILE_OPENER_METHOD</NAME>
#define GO_FILE_OPENER_METHOD(obj,name) \
        ((GO_FILE_OPENER_CLASS (G_OBJECT_GET_CLASS (obj)))->name)
</MACRO>
<STRUCT>
<NAME>GOFileOpenerClass</NAME>
struct _GOFileOpenerClass {
	GObjectClass parent_class;

	/* private */
	gboolean  (*can_probe) (GOFileOpener const *fo,
				FileProbeLevel pl);
	gboolean  (*probe) (GOFileOpener const *fo,
	                    GsfInput *input,
	                    FileProbeLevel pl);
	void      (*open)  (GOFileOpener const *fo,
			    gchar const *opt_enc,
	                    IOContext *io_context,
	                    gpointer  fixme_fixme_workbook_view,
	                    GsfInput *input);
};
</STRUCT>
<STRUCT>
<NAME>GOFileOpener</NAME>
struct _GOFileOpener {
	GObject parent;

	/* private */
	gchar	*id;
	gchar	*description;
	GSList	*suffixes;
	GSList	*mimes;
	gboolean encoding_dependent;

	GOFileOpenerProbeFunc probe_func;
	GOFileOpenerOpenFunc  open_func;
};
</STRUCT>
<FUNCTION>
<NAME>go_file_opener_setup</NAME>
<RETURNS>void </RETURNS>
GOFileOpener *fo, const gchar *id,const gchar *description,GSList *suffixes,GSList *mimes,gboolean encoding_dependent,GOFileOpenerProbeFunc probe_func,GOFileOpenerOpenFunc open_func
</FUNCTION>
<MACRO>
<NAME>GO_FILE_SAVER_METHOD</NAME>
#define GO_FILE_SAVER_METHOD(obj,name) \
        ((GO_FILE_SAVER_CLASS (G_OBJECT_GET_CLASS (obj)))->name)
</MACRO>
<MACRO>
<NAME>GO_FILE_SAVER_CLASS</NAME>
#define GO_FILE_SAVER_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GO_FILE_SAVER, GOFileSaverClass))
</MACRO>
<STRUCT>
<NAME>GOFileSaverClass</NAME>
struct _GOFileSaverClass {
	GObjectClass parent_class;

	/* private */
	void (*save) (GOFileSaver const *fs,
	              IOContext *io_context,
	              gconstpointer wbv,
	              GsfOutput *output);

	gboolean (*set_export_options) (GOFileSaver *fs,
					const char *options,
					GError **err);
};
</STRUCT>
<STRUCT>
<NAME>GOFileSaver</NAME>
struct _GOFileSaver {
	GObject parent;

	/* private */
	gchar                *id;
	gchar                *mime_type;
	gchar                *extension;
	gchar                *description;
	gboolean              overwrite_files;
	FileFormatLevel       format_level;
	FileSaveScope         save_scope;
	GOFileSaverSaveFunc   save_func;
};
</STRUCT>
<MACRO>
<NAME>GO_PLUGIN_LOADER_TYPE</NAME>
#define GO_PLUGIN_LOADER_TYPE		(go_plugin_loader_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_LOADER</NAME>
#define GO_PLUGIN_LOADER(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_LOADER_TYPE, GOPluginLoader))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_LOADER</NAME>
#define IS_GO_PLUGIN_LOADER(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_LOADER_TYPE))
</MACRO>
<MACRO>
<NAME>GO_PLUGIN_LOADER_CLASS</NAME>
#define GO_PLUGIN_LOADER_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GO_PLUGIN_LOADER_TYPE, GOPluginLoaderClass))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN_LOADER_CLASS</NAME>
#define IS_GO_PLUGIN_LOADER_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GO_PLUGIN_LOADER_TYPE))
</MACRO>
<STRUCT>
<NAME>GOPluginLoaderClass</NAME>
typedef struct {
	GTypeInterface base;

	void (*load_base)		(GOPluginLoader *l, ErrorInfo **err);
	void (*unload_base)		(GOPluginLoader *l, ErrorInfo **err);
	void (*set_attributes)		(GOPluginLoader *l, GHashTable *attrs, ErrorInfo **err);
	gboolean (*service_load)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);
	gboolean (*service_unload)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);

	void (*load_service_file_opener)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);
	void (*unload_service_file_opener)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);

	void (*load_service_file_saver)		(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);
	void (*unload_service_file_saver)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);

	void (*load_service_plugin_loader)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);
	void (*unload_service_plugin_loader)	(GOPluginLoader *l, GOPluginService *s, ErrorInfo **err);
} GOPluginLoaderClass;
</STRUCT>
<FUNCTION>
<NAME>go_plugin_loader_get_type</NAME>
<RETURNS>GType	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_set_attributes</NAME>
<RETURNS>void	   </RETURNS>
GOPluginLoader *l, GHashTable *attrs,ErrorInfo **err
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_get_plugin</NAME>
<RETURNS>GOPlugin *</RETURNS>
GOPluginLoader *l
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_set_plugin</NAME>
<RETURNS>void	   </RETURNS>
GOPluginLoader *l, GOPlugin *p
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_load_base</NAME>
<RETURNS>void	   </RETURNS>
GOPluginLoader *l, ErrorInfo **err
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_unload_base</NAME>
<RETURNS>void	   </RETURNS>
GOPluginLoader *l, ErrorInfo **err
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_load_service</NAME>
<RETURNS>void	   </RETURNS>
GOPluginLoader *l, GOPluginService *s, ErrorInfo **err
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_unload_service</NAME>
<RETURNS>void	   </RETURNS>
GOPluginLoader *l, GOPluginService *s, ErrorInfo **err
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_loader_is_base_loaded</NAME>
<RETURNS>gboolean   </RETURNS>
GOPluginLoader *l
</FUNCTION>
<MACRO>
<NAME>GO_PLUGIN_TYPE</NAME>
#define GO_PLUGIN_TYPE	(go_plugin_get_type ())
</MACRO>
<MACRO>
<NAME>GO_PLUGIN</NAME>
#define GO_PLUGIN(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_PLUGIN_TYPE, GOPlugin))
</MACRO>
<MACRO>
<NAME>IS_GO_PLUGIN</NAME>
#define IS_GO_PLUGIN(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_PLUGIN_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_plugin_get_type</NAME>
<RETURNS>GType	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_activate</NAME>
<RETURNS>void         </RETURNS>
GOPlugin *plugin, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_deactivate</NAME>
<RETURNS>void         </RETURNS>
GOPlugin *plugin, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_is_active</NAME>
<RETURNS>gboolean     </RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_can_deactivate</NAME>
<RETURNS>gboolean     </RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_load_service</NAME>
<RETURNS>void         </RETURNS>
GOPlugin *plugin, GOPluginService *service, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_unload_service</NAME>
<RETURNS>void         </RETURNS>
GOPlugin *plugin, GOPluginService *service, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_is_loaded</NAME>
<RETURNS>gboolean     </RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_use_ref</NAME>
<RETURNS>void         </RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_use_unref</NAME>
<RETURNS>void         </RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_type_module</NAME>
<RETURNS>GTypeModule *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_dir_name</NAME>
<RETURNS>char const  *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_id</NAME>
<RETURNS>char const  *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_name</NAME>
<RETURNS>char const  *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_description</NAME>
<RETURNS>char const  *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_textdomain</NAME>
<RETURNS>char const  *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_services</NAME>
<RETURNS>GSList      *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_get_dependencies_ids</NAME>
<RETURNS>GSList      *</RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_init</NAME>
<RETURNS>void	</RETURNS>
GOCmdContext *context,GSList const *known_states,GSList const *active_plugins,GSList *plugin_dirs,gboolean activate_new_plugins,GType  default_loader_type
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_shutdown</NAME>
<RETURNS>GSList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_add</NAME>
<RETURNS>void	</RETURNS>
GOCmdContext *context,GSList const *known_states,GSList const *active_plugins,GSList *plugin_dirs,GType  default_loader_type
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_register_loader</NAME>
<RETURNS>void	  </RETURNS>
const gchar *id_str, GOPluginService *service
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_unregister_loader</NAME>
<RETURNS>void	  </RETURNS>
const gchar *id_str
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_get_plugin_by_id</NAME>
<RETURNS>GOPlugin *</RETURNS>
const gchar *plugin_id
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_get_available_plugins</NAME>
<RETURNS>GSList	 *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_get_active_plugins</NAME>
<RETURNS>GSList	 *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_rescan</NAME>
<RETURNS>void	  </RETURNS>
ErrorInfo **ret_error, GSList **ret_new_plugins
</FUNCTION>
<FUNCTION>
<NAME>go_plugins_get_plugin_dir</NAME>
<RETURNS>char 	 *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_db_mark_plugin_for_deactivation</NAME>
<RETURNS>void	  </RETURNS>
GOPlugin *plugin, gboolean mark
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_db_is_plugin_marked_for_deactivation</NAME>
<RETURNS>gboolean  </RETURNS>
GOPlugin *plugin
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_db_activate_plugin_list</NAME>
<RETURNS>void	  </RETURNS>
GSList *plugins, ErrorInfo **ret_error
</FUNCTION>
<FUNCTION>
<NAME>go_plugin_db_deactivate_plugin_list</NAME>
<RETURNS>void	  </RETURNS>
GSList *plugins, ErrorInfo **ret_error
</FUNCTION>
<MACRO>
<NAME>GOG_GRID_LINE_TYPE</NAME>
#define GOG_GRID_LINE_TYPE	(gog_grid_line_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_GRID_LINE</NAME>
#define GOG_GRID_LINE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_GRID_LINE_TYPE, GogGridLine))
</MACRO>
<MACRO>
<NAME>IS_GOG_GRID_LINE</NAME>
#define IS_GOG_GRID_LINE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_GRID_LINE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_grid_line_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_grid_line_is_minor</NAME>
<RETURNS>gboolean </RETURNS>
GogGridLine *ggl
</FUNCTION>
<TYPEDEF>
<NAME>GogGridLineView</NAME>
typedef GogView GogGridLineView;
</TYPEDEF>
<FUNCTION>
<NAME>gog_grid_line_view_render_stripes</NAME>
<RETURNS>void </RETURNS>
GogView *view
</FUNCTION>
<FUNCTION>
<NAME>gog_grid_line_view_render_lines</NAME>
<RETURNS>void </RETURNS>
GogView *view
</FUNCTION>
<MACRO>
<NAME>GOG_GRID_TYPE</NAME>
#define GOG_GRID_TYPE	(gog_grid_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_GRID</NAME>
#define GOG_GRID(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_GRID_TYPE, GogGrid))
</MACRO>
<MACRO>
<NAME>IS_GOG_GRID</NAME>
#define IS_GOG_GRID(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_GRID_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_grid_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GOG_GRAPH_TYPE</NAME>
#define GOG_GRAPH_TYPE	(gog_graph_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_GRAPH</NAME>
#define GOG_GRAPH(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_GRAPH_TYPE, GogGraph))
</MACRO>
<MACRO>
<NAME>IS_GOG_GRAPH</NAME>
#define IS_GOG_GRAPH(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_GRAPH_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_graph_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_validate_chart_layout</NAME>
<RETURNS>gboolean  </RETURNS>
GogGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_num_cols</NAME>
<RETURNS>unsigned  </RETURNS>
GogGraph const *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_num_rows</NAME>
<RETURNS>unsigned  </RETURNS>
GogGraph const *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_dup</NAME>
<RETURNS>GogGraph *</RETURNS>
GogGraph const *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_get_theme</NAME>
<RETURNS>GogTheme *</RETURNS>
GogGraph const *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_set_theme</NAME>
<RETURNS>void	  </RETURNS>
GogGraph *graph, GogTheme *theme
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_get_data</NAME>
<RETURNS>GSList   *</RETURNS>
GogGraph const *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_ref_data</NAME>
<RETURNS>GOData   *</RETURNS>
GogGraph *graph, GOData *dat
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_unref_data</NAME>
<RETURNS>void      </RETURNS>
GogGraph *graph, GOData *dat
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_get_size</NAME>
<RETURNS>void	  </RETURNS>
GogGraph *graph, double *width, double *height
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_set_size</NAME>
<RETURNS>void      </RETURNS>
GogGraph *graph, double width, double height
</FUNCTION>
<MACRO>
<NAME>GOG_GRAPH_VIEW_TYPE</NAME>
#define GOG_GRAPH_VIEW_TYPE	(gog_graph_view_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_GRAPH_VIEW</NAME>
#define GOG_GRAPH_VIEW(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_GRAPH_VIEW_TYPE, GogGraphView))
</MACRO>
<MACRO>
<NAME>IS_GOG_GRAPH_VIEW</NAME>
#define IS_GOG_GRAPH_VIEW(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_GRAPH_VIEW_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_graph_view_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_view_get_selection</NAME>
<RETURNS>GogView *</RETURNS>
GogGraphView *gview
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_view_set_selection</NAME>
<RETURNS>void 	 </RETURNS>
GogGraphView *gview, GogObject *gobj
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_get_supported_image_formats</NAME>
<RETURNS>GSList 	 *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_export_image</NAME>
<RETURNS>gboolean  </RETURNS>
GogGraph *graph, GOImageFormat format,GsfOutput *output, double x_dpi, double y_dpi
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_view_handle_event</NAME>
<RETURNS>void  	 </RETURNS>
GogGraphView *gview, GdkEvent *event, double x_offset, double y_offset
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_render_to_cairo</NAME>
<RETURNS>void 	 </RETURNS>
GogGraph *graph, cairo_t *cairo, double w, double h
</FUNCTION>
<ENUM>
<NAME>GogAxisPolarUnit</NAME>
typedef enum {
	GOG_AXIS_POLAR_UNIT_DEGREES,
	GOG_AXIS_POLAR_UNIT_RADIANS,
	GOG_AXIS_POLAR_UNIT_GRADS,
	GOG_AXIS_POLAR_UNIT_MAX
} GogAxisPolarUnit;
</ENUM>
<ENUM>
<NAME>GogAxisElemType</NAME>
typedef enum {
	GOG_AXIS_ELEM_MIN = 0,
	GOG_AXIS_ELEM_MAX,
	GOG_AXIS_ELEM_MAJOR_TICK,
	GOG_AXIS_ELEM_MINOR_TICK,
	GOG_AXIS_ELEM_CROSS_POINT,
	GOG_AXIS_ELEM_MAX_ENTRY
} GogAxisElemType;
</ENUM>
<STRUCT>
<NAME>GogAxisTick</NAME>
typedef struct {
	double		 position;
	GogAxisTickTypes	 type;
	char 		*label;
} GogAxisTick;
</STRUCT>
<STRUCT>
<NAME>GogAxisMap</NAME>
</STRUCT>
<FUNCTION>
<NAME>gog_axis_map_new</NAME>
<RETURNS>GogAxisMap*</RETURNS>
GogAxis *axis, double offset, double length
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map</NAME>
<RETURNS>double	      </RETURNS>
GogAxisMap *map, double value
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_to_view</NAME>
<RETURNS>double	      </RETURNS>
GogAxisMap *map, double value
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_from_view</NAME>
<RETURNS>double	      </RETURNS>
GogAxisMap *map, double value
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_finite</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxisMap *map, double value
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_get_baseline</NAME>
<RETURNS>double	      </RETURNS>
GogAxisMap *map
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_get_extents</NAME>
<RETURNS>void 	      </RETURNS>
GogAxisMap *map, double *start, double *stop
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_get_bounds</NAME>
<RETURNS>void	      </RETURNS>
GogAxisMap *map, double *minimum, double *maximum
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_free</NAME>
<RETURNS>void 	      </RETURNS>
GogAxisMap *map
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_is_valid</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxisMap *map
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_map_is_inverted</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxisMap *map
</FUNCTION>
<MACRO>
<NAME>GOG_AXIS_TYPE</NAME>
#define GOG_AXIS_TYPE	(gog_axis_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_AXIS</NAME>
#define GOG_AXIS(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_AXIS_TYPE, GogAxis))
</MACRO>
<MACRO>
<NAME>IS_GOG_AXIS</NAME>
#define IS_GOG_AXIS(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_AXIS_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_axis_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_atype</NAME>
<RETURNS>GogAxisType   </RETURNS>
GogAxis const *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_is_center_on_ticks</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxis const *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_is_discrete</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxis const *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_is_inverted</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxis const *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_bounds</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxis const *axis,double *minima, double *maxima
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_set_bounds</NAME>
<RETURNS>void	      </RETURNS>
GogAxis *axis,double minimum, double maximum
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_set_extents</NAME>
<RETURNS>void 	      </RETURNS>
GogAxis *axis, double start, double stop
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_format</NAME>
<RETURNS>GOFormat     *</RETURNS>
GogAxis const *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_set_format</NAME>
<RETURNS>gboolean      </RETURNS>
GogAxis *axis, GOFormat *fmt
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_ticks</NAME>
<RETURNS>unsigned      </RETURNS>
GogAxis *axis, GogAxisTick **ticks
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_labels</NAME>
<RETURNS>GOData	     *</RETURNS>
GogAxis const *axis,GogPlot **plot_that_labeled_axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_entry</NAME>
<RETURNS>double 	      </RETURNS>
GogAxis const *axis, GogAxisElemType i,gboolean *user_defined
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_add_contributor</NAME>
<RETURNS>void 	      </RETURNS>
GogAxis *axis, GogObject *contrib
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_del_contributor</NAME>
<RETURNS>void 	      </RETURNS>
GogAxis *axis, GogObject *contrib
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_contributors</NAME>
<RETURNS>GSList const *</RETURNS>
GogAxis *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_clear_contributors</NAME>
<RETURNS>void	      </RETURNS>
GogAxis *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_bound_changed</NAME>
<RETURNS>void	      </RETURNS>
GogAxis *axis, GogObject *contrib
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_grid_line</NAME>
<RETURNS>GogGridLine  *</RETURNS>
GogAxis *axis, gboolean major
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_set_polar_unit</NAME>
<RETURNS>void	      		</RETURNS>
GogAxis *axis, GogAxisPolarUnit unit
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_polar_unit</NAME>
<RETURNS>GogAxisPolarUnit	</RETURNS>
GogAxis *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_polar_perimeter</NAME>
<RETURNS>double 			</RETURNS>
GogAxis *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_get_circular_rotation</NAME>
<RETURNS>double 			</RETURNS>
GogAxis *axis
</FUNCTION>
<MACRO>
<NAME>GOG_LABEL_TYPE</NAME>
#define GOG_LABEL_TYPE	(gog_label_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_LABEL</NAME>
#define GOG_LABEL(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_LABEL_TYPE, GogLabel))
</MACRO>
<MACRO>
<NAME>IS_GOG_LABEL</NAME>
#define IS_GOG_LABEL(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_LABEL_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_label_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GOG_REG_EQN_TYPE</NAME>
#define GOG_REG_EQN_TYPE	(gog_reg_eqn_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_REG_EQN</NAME>
#define GOG_REG_EQN(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_REG_EQN_TYPE, GogRegEqn))
</MACRO>
<MACRO>
<NAME>IS_GOG_REG_EQN</NAME>
#define IS_GOG_REG_EQN(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_REG_EQN_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_reg_eqn_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogOutlinedObject</NAME>
typedef struct {
	GogStyledObject	base;
	double	 padding_pts;
} GogOutlinedObject;
</STRUCT>
<TYPEDEF>
<NAME>GogOutlinedObjectClass</NAME>
typedef	GogStyledObjectClass GogOutlinedObjectClass; 
</TYPEDEF>
<MACRO>
<NAME>GOG_OUTLINED_OBJECT_TYPE</NAME>
#define GOG_OUTLINED_OBJECT_TYPE  (gog_outlined_object_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_OUTLINED_OBJECT</NAME>
#define GOG_OUTLINED_OBJECT(o)	  (G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_OUTLINED_OBJECT_TYPE, GogOutlinedObject))
</MACRO>
<MACRO>
<NAME>IS_GOG_OUTLINED_OBJECT</NAME>
#define IS_GOG_OUTLINED_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_OUTLINED_OBJECT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_outlined_object_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_outlined_object_get_pad</NAME>
<RETURNS>double </RETURNS>
GogOutlinedObject const *goo
</FUNCTION>
<TYPEDEF>
<NAME>GogOutlinedView</NAME>
typedef GogView		GogOutlinedView;
</TYPEDEF>
<STRUCT>
<NAME>GogOutlinedViewClass</NAME>
typedef struct {
	GogViewClass	base;
	gboolean	call_parent_render;
} GogOutlinedViewClass;
</STRUCT>
<MACRO>
<NAME>GOG_OUTLINED_VIEW_TYPE</NAME>
#define GOG_OUTLINED_VIEW_TYPE  	(gog_outlined_view_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_OUTLINED_VIEW</NAME>
#define GOG_OUTLINED_VIEW(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_OUTLINED_VIEW_TYPE, GogOutlinedView))
</MACRO>
<MACRO>
<NAME>IS_GOG_OUTLINED_VIEW</NAME>
#define IS_GOG_OUTLINED_VIEW(o) 	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_OUTLINED_VIEW_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_OUTLINED_VIEW_GET_CLASS</NAME>
#define GOG_OUTLINED_VIEW_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_OUTLINED_VIEW_TYPE, GogOutlinedViewClass))
</MACRO>
<FUNCTION>
<NAME>gog_outlined_view_get_type</NAME>
<RETURNS>GType   </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogSeriesElement</NAME>
typedef struct {
	GogStyledObject base;

	unsigned index;
} GogSeriesElement;
</STRUCT>
<STRUCT>
<NAME>GogSeriesElementClass</NAME>
typedef struct {
	GogStyledObjectClass base;

	/* Virtuals */
	gpointer (*gse_populate_editor) (GogObject *gobj,
					 GogEditor *editor,
					 GOCmdContext *cc);
} GogSeriesElementClass;
</STRUCT>
<MACRO>
<NAME>GOG_SERIES_ELEMENT_GET_CLASS</NAME>
#define GOG_SERIES_ELEMENT_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_SERIES_ELEMENT_TYPE, GogSeriesElementClass))
</MACRO>
<ENUM>
<NAME>GogSeriesPriority</NAME>
typedef enum {
	GOG_SERIES_REQUIRED,  /* it must be there */
	GOG_SERIES_SUGGESTED, /* allocator will fill it in, but use need not */
	GOG_SERIES_OPTIONAL,
	GOG_SERIES_ERRORS
} GogSeriesPriority;
</ENUM>
<MACRO>
<NAME>GOG_SERIES_ACCEPT_TREND_LINE</NAME>
#define GOG_SERIES_ACCEPT_TREND_LINE	1
</MACRO>
<STRUCT>
<NAME>GogSeriesDimDesc</NAME>
struct _GogSeriesDimDesc {
	char const *name;
	GogSeriesPriority	priority;
	gboolean		is_shared;
	GogDimType		val_type;
	GogMSDimType		ms_type;
};
</STRUCT>
<STRUCT>
<NAME>GogSeriesDesc</NAME>
struct _GogSeriesDesc {
	unsigned style_fields;
	unsigned num_dim;
	GogSeriesDimDesc const *dim;
};
</STRUCT>
<STRUCT>
<NAME>GogSeries</NAME>
struct _GogSeries {
	GogStyledObject base;

	int index;
	unsigned manual_index : 1;
	unsigned is_valid     : 1;
	unsigned needs_recalc : 1;
	unsigned acceptable_children : 1;

	GogPlot	  	  *plot;
	GogDatasetElement *values;
	gboolean	   has_legend;
	unsigned   	   num_elements;
	GogSeriesFillType  fill_type;
	GList		  *overrides;  /* GogSeriesElement (individual points) */

	GOLineInterpolation	interpolation;
};
</STRUCT>
<STRUCT>
<NAME>GogSeriesClass</NAME>
typedef struct {
	GogStyledObjectClass base;

	gboolean		 has_interpolation;
	gboolean		 has_fill_type;

	GogSeriesFillType const	*valid_fill_type_list;

	GType			 series_element_type;

	/* Virtuals */
	void (*dim_changed) (GogSeries *series, int dim_i);
	unsigned (*get_xy_data) (GogSeries const *series,
					double const **x, double const **y);
} GogSeriesClass;
</STRUCT>
<MACRO>
<NAME>GOG_SERIES_CLASS</NAME>
#define GOG_SERIES_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GOG_SERIES_TYPE, GogSeriesClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_SERIES_CLASS</NAME>
#define IS_GOG_SERIES_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_SERIES_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_SERIES_GET_CLASS</NAME>
#define GOG_SERIES_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_SERIES_TYPE, GogSeriesClass))
</MACRO>
<FUNCTION>
<NAME>gog_series_check_validity</NAME>
<RETURNS>void </RETURNS>
GogSeries *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_element</NAME>
<RETURNS>GogSeriesElement *</RETURNS>
GogSeries const *series, int index
</FUNCTION>
<MACRO>
<NAME>GOG_LEGEND_TYPE</NAME>
#define GOG_LEGEND_TYPE		(gog_legend_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_LEGEND</NAME>
#define GOG_LEGEND(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_LEGEND_TYPE, GogLegend))
</MACRO>
<MACRO>
<NAME>IS_GOG_LEGEND</NAME>
#define IS_GOG_LEGEND(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_LEGEND_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_legend_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GogErrorBarType</NAME>
typedef enum {
	GOG_ERROR_BAR_TYPE_NONE,
	GOG_ERROR_BAR_TYPE_ABSOLUTE,
	GOG_ERROR_BAR_TYPE_RELATIVE,
	GOG_ERROR_BAR_TYPE_PERCENT
} GogErrorBarType;
</ENUM>
<ENUM>
<NAME>GogErrorBarDisplay</NAME>
typedef enum {
	GOG_ERROR_BAR_DISPLAY_NONE,
	GOG_ERROR_BAR_DISPLAY_POSITIVE,
	GOG_ERROR_BAR_DISPLAY_NEGATIVE,
	GOG_ERROR_BAR_DISPLAY_BOTH
} GogErrorBarDisplay;
</ENUM>
<STRUCT>
<NAME>GogErrorBar</NAME>
struct  _GogErrorBar{
	GObject	base;
	GogErrorBarType type;
	GogSeries *series;
	int dim_i;
	int error_i;
	GogErrorBarDisplay display;
	float width;
	GogStyle* style;
};
</STRUCT>
<MACRO>
<NAME>GOG_ERROR_BAR_TYPE</NAME>
#define GOG_ERROR_BAR_TYPE		(gog_error_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_ERROR_BAR</NAME>
#define GOG_ERROR_BAR(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_ERROR_BAR_TYPE, GogErrorBar))
</MACRO>
<MACRO>
<NAME>IS_GOG_ERROR_BAR</NAME>
#define IS_GOG_ERROR_BAR(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_ERROR_BAR_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_error_bar_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_error_bar_dup</NAME>
<RETURNS>GogErrorBar  	*</RETURNS>
GogErrorBar const *bar
</FUNCTION>
<FUNCTION>
<NAME>gog_error_bar_prefs</NAME>
<RETURNS>gpointer 	 </RETURNS>
GogSeries *series, char const *property,gboolean horizontal, GogDataAllocator *dalloc,GOCmdContext *cc
</FUNCTION>
<FUNCTION>
<NAME>gog_error_bar_get_bounds</NAME>
<RETURNS>gboolean 	 </RETURNS>
const GogErrorBar *bar, int index,double *min, double *max
</FUNCTION>
<FUNCTION>
<NAME>gog_error_bar_get_minmax</NAME>
<RETURNS>void 		 </RETURNS>
const GogErrorBar *bar,double *min, double *max
</FUNCTION>
<FUNCTION>
<NAME>gog_error_bar_render</NAME>
<RETURNS>void 		 </RETURNS>
const GogErrorBar *bar, GogRenderer *rend,GogAxisMap *x_map, GogAxisMap *y_map,double x, double y,double minus,double plus,gboolean horizontal
</FUNCTION>
<FUNCTION>
<NAME>gog_error_bar_is_visible</NAME>
<RETURNS>gboolean 	 </RETURNS>
GogErrorBar *bar
</FUNCTION>
<STRUCT>
<NAME>GogSmoothedCurve</NAME>
struct  _GogSmoothedCurve {
	GogTrendLine	base;
	
	GogSeries 	  *series;
	double *x, *y;
	unsigned nb;
};
</STRUCT>
<STRUCT>
<NAME>GogSmoothedCurveClass</NAME>
typedef struct {
	GogTrendLineClass base;

} GogSmoothedCurveClass;
</STRUCT>
<MACRO>
<NAME>GOG_SMOOTHED_CURVE_TYPE</NAME>
#define GOG_SMOOTHED_CURVE_TYPE	(gog_smoothed_curve_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_SMOOTHED_CURVE</NAME>
#define GOG_SMOOTHED_CURVE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_SMOOTHED_CURVE_TYPE, GogSmoothedCurve))
</MACRO>
<MACRO>
<NAME>IS_GOG_SMOOTHED_CURVE</NAME>
#define IS_GOG_SMOOTHED_CURVE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_SMOOTHED_CURVE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_smoothed_curve_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GogAxisPosition</NAME>
typedef enum {
	GOG_AXIS_AT_LOW,
	GOG_AXIS_CROSS,
	GOG_AXIS_AT_HIGH,
	GOG_AXIS_AUTO
} GogAxisPosition;
</ENUM>
<ENUM>
<NAME>GogAxisTickTypes</NAME>
typedef enum {
	GOG_AXIS_TICK_NONE,
	GOG_AXIS_TICK_MAJOR,
	GOG_AXIS_TICK_MINOR
} GogAxisTickTypes;
</ENUM>
<MACRO>
<NAME>GOG_AXIS_LINE_TYPE</NAME>
#define GOG_AXIS_LINE_TYPE	(gog_axis_line_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_AXIS_LINE</NAME>
#define GOG_AXIS_LINE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_AXIS_LINE_TYPE, GogAxisLine))
</MACRO>
<MACRO>
<NAME>IS_GOG_AXIS_LINE</NAME>
#define IS_GOG_AXIS_LINE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_AXIS_LINE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_axis_line_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogDatasetElement</NAME>
typedef struct {
	GOData	   *data;
	GogDataset *set;
	int	    dim_i;
	gulong	    handler;
} GogDatasetElement;
</STRUCT>
<STRUCT>
<NAME>GogDatasetClass</NAME>
typedef struct {
	GTypeInterface		   base;

	GogDatasetElement *(*get_elem) (GogDataset const *set, int dim_i);
	void (*set_dim)     (GogDataset *set, int dim_i,
			     GOData *val, GError **err);
	void (*dims)	    (GogDataset const *set, int *first, int *last);
	void (*dim_changed) (GogDataset *set, int dim_i);
} GogDatasetClass;
</STRUCT>
<MACRO>
<NAME>GOG_DATASET_TYPE</NAME>
#define GOG_DATASET_TYPE		(gog_dataset_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_DATASET</NAME>
#define GOG_DATASET(o)			(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_DATASET_TYPE, GogDataset))
</MACRO>
<MACRO>
<NAME>IS_GOG_DATASET</NAME>
#define IS_GOG_DATASET(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_DATASET_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_DATASET_CLASS</NAME>
#define GOG_DATASET_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST ((k), GOG_DATASET_TYPE, GogDatasetClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_DATASET_CLASS</NAME>
#define IS_GOG_DATASET_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_DATASET_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_DATASET_GET_CLASS</NAME>
#define GOG_DATASET_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_INTERFACE ((o), GOG_DATASET_TYPE, GogDatasetClass))
</MACRO>
<FUNCTION>
<NAME>gog_dataset_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_dims</NAME>
<RETURNS>void    </RETURNS>
GogDataset const *set, int *first, int *last
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_get_dim</NAME>
<RETURNS>GOData *</RETURNS>
GogDataset const *set, int dim_i
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_set_dim</NAME>
<RETURNS>void	</RETURNS>
GogDataset *set, int dim_i,GOData *val, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_finalize</NAME>
<RETURNS>void 		   </RETURNS>
GogDataset *set
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_parent_changed</NAME>
<RETURNS>void 		   </RETURNS>
GogDataset *set, gboolean was_set
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_get_elem</NAME>
<RETURNS>GogDatasetElement *</RETURNS>
GogDataset const *set, int dim_i
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_set_dim_internal</NAME>
<RETURNS>void </RETURNS>
GogDataset *set, int dim_i,GOData *val, GogGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_dataset_dup_to_simple</NAME>
<RETURNS>void </RETURNS>
GogDataset const *src, GogDataset *dst
</FUNCTION>
<STRUCT>
<NAME>GogRegCurve</NAME>
struct  _GogRegCurve {
	GogTrendLine	base;
	
	GogSeries 	  *series;
	gboolean  	   weighted;
	GODataVector 	  *weights;
	GogDatasetElement *bounds;
	gboolean	   skip_invalid; /* do not take into account invalid data */
	int		   ninterp;	 /* how many points to use for display the curve as a vpath */
	double		  *a;		 /* calculated coefficients, must be allocated by derived class */
	double		   R2;		 /* squared regression coefficient */
	char		  *equation;
};
</STRUCT>
<STRUCT>
<NAME>GogRegCurveClass</NAME>
typedef struct {
	GogTrendLineClass base;

	double 		(*get_value_at) (GogRegCurve *reg_curve, double x);
	gchar const* 	(*get_equation) (GogRegCurve *reg_curve);
	void 		(*populate_editor) (GogRegCurve *reg_curve, gpointer table);
} GogRegCurveClass;
</STRUCT>
<MACRO>
<NAME>GOG_REG_CURVE_TYPE</NAME>
#define GOG_REG_CURVE_TYPE	(gog_reg_curve_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_REG_CURVE</NAME>
#define GOG_REG_CURVE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_REG_CURVE_TYPE, GogRegCurve))
</MACRO>
<MACRO>
<NAME>IS_GOG_REG_CURVE</NAME>
#define IS_GOG_REG_CURVE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_REG_CURVE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_reg_curve_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_reg_curve_get_equation</NAME>
<RETURNS>gchar const *</RETURNS>
GogRegCurve *reg_curve
</FUNCTION>
<FUNCTION>
<NAME>gog_reg_curve_get_R2</NAME>
<RETURNS>double       </RETURNS>
GogRegCurve *reg_curve
</FUNCTION>
<FUNCTION>
<NAME>gog_reg_curve_get_bounds</NAME>
<RETURNS>void         </RETURNS>
GogRegCurve *reg_curve, double *xmin, double *xmax
</FUNCTION>
<MACRO>
<NAME>GOG_STYLE_TYPE</NAME>
#define GOG_STYLE_TYPE	(gog_style_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_STYLE</NAME>
#define GOG_STYLE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_STYLE_TYPE, GogStyle))
</MACRO>
<MACRO>
<NAME>IS_GOG_STYLE</NAME>
#define IS_GOG_STYLE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_STYLE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_style_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>GogStyleFlag</NAME>
typedef enum {
	GOG_STYLE_OUTLINE	= 1 << 0,
	GOG_STYLE_FILL		= 1 << 1,
	GOG_STYLE_LINE		= 1 << 2,
	GOG_STYLE_MARKER	= 1 << 3,
	GOG_STYLE_FONT		= 1 << 4,
	GOG_STYLE_TEXT_LAYOUT	= 1 << 5,
	GOG_STYLE_INTERPOLATION	= 1 << 6,
	GOG_STYLE_MARKER_NO_COLOR	= 1 << 7,
	GOG_STYLE_ALL		= 0x1F
} GogStyleFlag;
</ENUM>
<ENUM>
<NAME>GogFillStyle</NAME>
typedef enum {
	GOG_FILL_STYLE_NONE	= 0,
	GOG_FILL_STYLE_PATTERN	= 1,
	GOG_FILL_STYLE_GRADIENT	= 2,
	GOG_FILL_STYLE_IMAGE	= 3
} GogFillStyle;
</ENUM>
<ENUM>
<NAME>GogImageType</NAME>
typedef enum {
	GOG_IMAGE_STRETCHED,
	GOG_IMAGE_WALLPAPER,
	GOG_IMAGE_CENTERED
} GogImageType;
</ENUM>
<STRUCT>
<NAME>GogStyleLine</NAME>
typedef struct {
	/* <0 == no outline,
	 * =0 == hairline : unscaled, minimum useful (can be bigger than visible) size.
	 * >0 in pts */
	float	 	 width;
	GOLineDashType 	 dash_type;
	gboolean	 auto_dash;
	GOColor	 	 color;
	gboolean 	 auto_color;
	unsigned	 pattern_unimplemented_yet; /* TODO: implement. Not used
				and must not be used before implementation */
} GogStyleLine;
</STRUCT>
<STRUCT>
<NAME>GogStyleMark</NAME>
typedef struct {
	GOMarker *mark;
	gboolean auto_shape;
	gboolean auto_outline_color;
	gboolean auto_fill_color;
} GogStyleMark;
</STRUCT>
<STRUCT>
<NAME>GogStyle</NAME>
struct _GogStyle {
	GObject	base;

	GogStyleFlag	interesting_fields;
	GogStyleFlag	disable_theming;

	GogStyleLine	outline, line;
	struct {
		GogFillStyle	type;
		gboolean	auto_type;
		gboolean	auto_fore, auto_back;	/* share between pattern and gradient */
		gboolean	invert_if_negative;	/* placeholder for XL */

		/* This could all be a union but why bother ? */
		GOPattern pattern;
		struct {
			GOGradientDirection dir;
			float   brightness; /* < 0 => 2 color */
		} gradient;
		struct {
			GogImageType	 type;
			GOImage	 *image;
			char		*filename;
		} image;
	} fill;
	GogStyleMark marker;
	struct {
		GOColor		 color;
		GOFont const 	*font;
		gboolean 	 auto_scale;
	} font;
	struct {
		double		 angle;
		gboolean	 auto_angle; 
	} text_layout;	
};
</STRUCT>
<FUNCTION>
<NAME>gog_style_new</NAME>
<RETURNS>GogStyle  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_style_dup</NAME>
<RETURNS>GogStyle  *</RETURNS>
GogStyle const *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_assign</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *dst, GogStyle const *src
</FUNCTION>
<FUNCTION>
<NAME>gog_style_apply_theme</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *dst, GogStyle const *src
</FUNCTION>
<FUNCTION>
<NAME>gog_style_get_marker</NAME>
<RETURNS>GOMarker const *</RETURNS>
GogStyle *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_set_marker</NAME>
<RETURNS>void            </RETURNS>
GogStyle *style, GOMarker *marker
</FUNCTION>
<FUNCTION>
<NAME>gog_style_set_font_desc</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *style,PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>gog_style_set_font</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *style, GOFont const *font
</FUNCTION>
<FUNCTION>
<NAME>gog_style_set_fill_brightness</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *style, float brightness
</FUNCTION>
<FUNCTION>
<NAME>gog_style_set_fill_image_filename</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *style, char *filename
</FUNCTION>
<FUNCTION>
<NAME>gog_style_set_text_angle</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *style, double angle
</FUNCTION>
<FUNCTION>
<NAME>gog_style_is_different_size</NAME>
<RETURNS>gboolean   </RETURNS>
GogStyle const *a, GogStyle const *b
</FUNCTION>
<FUNCTION>
<NAME>gog_style_is_marker_visible</NAME>
<RETURNS>gboolean   </RETURNS>
GogStyle const *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_is_line_visible</NAME>
<RETURNS>gboolean   </RETURNS>
GogStyle const *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_is_outline_visible</NAME>
<RETURNS>gboolean   </RETURNS>
GogStyle const *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_is_fill_visible</NAME>
<RETURNS>gboolean   </RETURNS>
GogStyle const *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_force_auto</NAME>
<RETURNS>void	   </RETURNS>
GogStyle *style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_populate_editor</NAME>
<RETURNS>void 	   </RETURNS>
GogStyle *style,GogEditor *editor,GogStyle *default_style,GOCmdContext *cc,GObject *object_with_style,gboolean watch_for_external_change
</FUNCTION>
<FUNCTION>
<NAME>gog_style_get_editor</NAME>
<RETURNS>gpointer   </RETURNS>
GogStyle *style,GogStyle *default_style,GOCmdContext *cc,GObject *object_with_style
</FUNCTION>
<FUNCTION>
<NAME>gog_style_create_cairo_pattern</NAME>
<RETURNS>cairo_pattern_t *</RETURNS>
GogStyle const *style, cairo_t *cr
</FUNCTION>
<FUNCTION>
<NAME>gog_guru</NAME>
<RETURNS>GtkWidget *</RETURNS>
GogGraph *graph, GogDataAllocator *dalloc,GOCmdContext *cc, GClosure *closure
</FUNCTION>
<FUNCTION>
<NAME>gog_guru_get_help_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *guru
</FUNCTION>
<STRUCT>
<NAME>GogChartMapPolarData</NAME>
typedef struct {
	double cx, cy;
	double rx, ry;
	double th0, th1;
} GogChartMapPolarData;
</STRUCT>
<STRUCT>
<NAME>GogChartMap</NAME>
</STRUCT>
<FUNCTION>
<NAME>gog_chart_map_new</NAME>
<RETURNS>GogChartMap 	*</RETURNS>
GogChart *chart, GogViewAllocation const *area,GogAxis *axis0, GogAxis *axis1, GogAxis *axis2,gboolean fill_area
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_2D_to_view</NAME>
<RETURNS>void 		 </RETURNS>
GogChartMap *map, double x, double y, double *u, double *v
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_get_axis_map</NAME>
<RETURNS>GogAxisMap	*</RETURNS>
GogChartMap *map, unsigned int index
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_is_valid</NAME>
<RETURNS>gboolean	 </RETURNS>
GogChartMap *map
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_free</NAME>
<RETURNS>void		 </RETURNS>
GogChartMap *map
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_make_path</NAME>
<RETURNS>GOPath 		*</RETURNS>
GogChartMap *map, double const *x, double const *y,int n_points,GOLineInterpolation interpolation
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_make_close_path</NAME>
<RETURNS>GOPath 		*</RETURNS>
GogChartMap *map, double const *x, double const *y,int n_points,GogSeriesFillType fill_type
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_map_get_polar_parms</NAME>
<RETURNS>GogChartMapPolarData *</RETURNS>
GogChartMap *map
</FUNCTION>
<STRUCT>
<NAME>GogPlotType</NAME>
struct _GogPlotType {
	GogPlotFamily 	*family;
	char 		*engine;

	char 		*name, *sample_image_file;
	char 		*description; /* untranslated */
	int 		 col, row;

	GHashTable 	*properties;
}; 
</STRUCT>
<STRUCT>
<NAME>GogPlotFamily</NAME>
struct _GogPlotFamily {
	char *name, *sample_image_file;
	int priority;

	GogAxisSet	 axis_set;

	GHashTable *types;
}; 
</STRUCT>
<FUNCTION>
<NAME>gog_plot_families</NAME>
<RETURNS>GHashTable const *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_family_by_name</NAME>
<RETURNS>GogPlotFamily *</RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_family_register</NAME>
<RETURNS>GogPlotFamily *</RETURNS>
char const *name, char const *sample_image_file,int priority, GogAxisSet axis_set
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_type_register</NAME>
<RETURNS>GogPlotType   *</RETURNS>
GogPlotFamily *famlily, int col, int row,char const *name, char const *sample_image_file,char const *description, char const *engine
</FUNCTION>
<STRUCT>
<NAME>GogTrendLineType</NAME>
struct _GogTrendLineType {
	char *engine;

	char *name;
	char *description; /* untranslated */

	GHashTable *properties;
};
</STRUCT>
<FUNCTION>
<NAME>gog_trend_line_types</NAME>
<RETURNS>GHashTable const *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_plugin_services_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_plugin_services_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<TYPEDEF>
<NAME>GdkPixbuf</NAME>
typedef struct HACK_GdkPixbuf GdkPixbuf;
</TYPEDEF>
<ENUM>
<NAME>GtkAnchorType</NAME>
typedef enum
{
  GTK_ANCHOR_CENTER,
  GTK_ANCHOR_NORTH,
  GTK_ANCHOR_NORTH_WEST,
  GTK_ANCHOR_NORTH_EAST,
  GTK_ANCHOR_SOUTH,
  GTK_ANCHOR_SOUTH_WEST,
  GTK_ANCHOR_SOUTH_EAST,
  GTK_ANCHOR_WEST,
  GTK_ANCHOR_EAST,
  GTK_ANCHOR_N		= GTK_ANCHOR_NORTH,
  GTK_ANCHOR_NW		= GTK_ANCHOR_NORTH_WEST,
  GTK_ANCHOR_NE		= GTK_ANCHOR_NORTH_EAST,
  GTK_ANCHOR_S		= GTK_ANCHOR_SOUTH,
  GTK_ANCHOR_SW		= GTK_ANCHOR_SOUTH_WEST,
  GTK_ANCHOR_SE		= GTK_ANCHOR_SOUTH_EAST,
  GTK_ANCHOR_W		= GTK_ANCHOR_WEST,
  GTK_ANCHOR_E		= GTK_ANCHOR_EAST
} GtkAnchorType;
</ENUM>
<MACRO>
<NAME>GOG_RENDERER_CAIRO_WITH_SVG</NAME>
#define GOG_RENDERER_CAIRO_WITH_SVG
</MACRO>
<MACRO>
<NAME>GOG_RENDERER_CAIRO_WITH_PDF</NAME>
#define GOG_RENDERER_CAIRO_WITH_PDF
</MACRO>
<MACRO>
<NAME>GOG_RENDERER_CAIRO_WITH_PS</NAME>
#define GOG_RENDERER_CAIRO_WITH_PS
</MACRO>
<MACRO>
<NAME>GOG_RENDERER_HAIRLINE_WIDTH_PTS</NAME>
#define GOG_RENDERER_HAIRLINE_WIDTH_PTS	0.5
</MACRO>
<MACRO>
<NAME>GOG_RENDERER_GRIP_SIZE</NAME>
#define GOG_RENDERER_GRIP_SIZE	4
</MACRO>
<MACRO>
<NAME>GOG_RENDERER_TYPE</NAME>
#define GOG_RENDERER_TYPE	  (gog_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_RENDERER</NAME>
#define GOG_RENDERER(o)           (G_TYPE_CHECK_INSTANCE_CAST((o), GOG_RENDERER_TYPE, GogRenderer))
</MACRO>
<MACRO>
<NAME>IS_GOG_RENDERER</NAME>
#define IS_GOG_RENDERER(o)        (G_TYPE_CHECK_INSTANCE_TYPE((o), GOG_RENDERER_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_RENDERER_GET_CLASS</NAME>
#define GOG_RENDERER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), GOG_RENDERER_TYPE, GogRendererClass))
</MACRO>
<FUNCTION>
<NAME>gog_renderer_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_line_size</NAME>
<RETURNS>double </RETURNS>
GogRenderer const *r, double width
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_pt2r_x</NAME>
<RETURNS>double </RETURNS>
GogRenderer const *r, double d
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_pt2r_y</NAME>
<RETURNS>double </RETURNS>
GogRenderer const *r, double d
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_pt2r</NAME>
<RETURNS>double </RETURNS>
GogRenderer const *r, double d
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_get_hairline_width_pts</NAME>
<RETURNS>double </RETURNS>
GogRenderer const *rend
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_stroke_serie</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, GOPath const *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_fill_serie</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, GOPath const *path, GOPath const *close_path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_shape</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, GOPath const *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_stroke_shape</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, GOPath const *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_fill_shape</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, GOPath const *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_rectangle</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, GogViewAllocation const *rect
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_stroke_rectangle</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, GogViewAllocation const *rect
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_fill_rectangle</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, GogViewAllocation const *rect
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_grip</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_selection_rectangle</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *renderer, GogViewAllocation const *rectangle
</FUNCTION>
<MACRO>
<NAME>gog_renderer_in_grip</NAME>
#define gog_renderer_in_grip(x,y,grip_x,grip_y) ((x) >= ((grip_x) - (GOG_RENDERER_GRIP_SIZE)) && \
						 (x) <= ((grip_x) + (GOG_RENDERER_GRIP_SIZE)) && \
						 (y) >= ((grip_y) - (GOG_RENDERER_GRIP_SIZE)) && \
						 (y) <= ((grip_y) + (GOG_RENDERER_GRIP_SIZE)))
</MACRO>
<FUNCTION>
<NAME>gog_renderer_draw_marker</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_text</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, char const *text,GogViewAllocation const *pos, GtkAnchorType anchor,gboolean use_markup
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_get_text_OBR</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, char const *text,gboolean use_markup, GOGeometryOBR *obr
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_get_text_AABR</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, char const *text,gboolean use_markup, GOGeometryAABR *aabr
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_push_style</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, GogStyle const *style
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_pop_style</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_push_clip</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, GOPath const *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_push_clip_rectangle</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend, double x, double y, double w, double h
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_pop_clip</NAME>
<RETURNS>void  </RETURNS>
GogRenderer *rend
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_update</NAME>
<RETURNS>gboolean	 </RETURNS>
GogRenderer *renderer, double w, double h
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_get_cairo_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GogRenderer *renderer
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_get_pixbuf</NAME>
<RETURNS>GdkPixbuf 	*</RETURNS>
GogRenderer *renderer
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_request_update</NAME>
<RETURNS>void  		 </RETURNS>
GogRenderer *renderer
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_render_to_cairo</NAME>
<RETURNS>gboolean	 </RETURNS>
GogRenderer *renderer, cairo_t *cairo,double width, double height
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_export_image</NAME>
<RETURNS>gboolean 	 </RETURNS>
GogRenderer *renderer, GOImageFormat format,GsfOutput *output, double x_dpi, double y_dpi
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_new</NAME>
<RETURNS>GogRenderer 	*</RETURNS>
GogGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_sharp_path</NAME>
<RETURNS>void  		</RETURNS>
GogRenderer *rend, ArtVpath *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_sharp_polygon</NAME>
<RETURNS>void  		</RETURNS>
GogRenderer *rend, ArtVpath *path, gboolean narrow
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_path</NAME>
<RETURNS>void  		</RETURNS>
GogRenderer *rend, ArtVpath const *path
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_polygon</NAME>
<RETURNS>void  		</RETURNS>
GogRenderer *rend, ArtVpath const *path, gboolean narrow
</FUNCTION>
<FUNCTION>
<NAME>gog_renderer_draw_bezier_path</NAME>
<RETURNS>void  		</RETURNS>
GogRenderer *rend, ArtBpath const *path
</FUNCTION>
<STRUCT>
<NAME>GogDataAllocatorClass</NAME>
typedef struct {
	GTypeInterface		   base;

	void	 (*allocate) (GogDataAllocator *a, GogPlot *plot);
	gpointer (*editor)   (GogDataAllocator *a, GogDataset *set,
			      int dim_i, GogDataType data_type);
} GogDataAllocatorClass;
</STRUCT>
<MACRO>
<NAME>GOG_DATA_ALLOCATOR_TYPE</NAME>
#define GOG_DATA_ALLOCATOR_TYPE		(gog_data_allocator_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_DATA_ALLOCATOR</NAME>
#define GOG_DATA_ALLOCATOR(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_DATA_ALLOCATOR_TYPE, GogDataAllocator))
</MACRO>
<MACRO>
<NAME>IS_GOG_DATA_ALLOCATOR</NAME>
#define IS_GOG_DATA_ALLOCATOR(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_DATA_ALLOCATOR_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_DATA_ALLOCATOR_CLASS</NAME>
#define GOG_DATA_ALLOCATOR_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GOG_DATA_ALLOCATOR_TYPE, GogDataAllocatorClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_DATA_ALLOCATOR_CLASS</NAME>
#define IS_GOG_DATA_ALLOCATOR_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_DATA_ALLOCATOR_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_DATA_ALLOCATOR_GET_CLASS</NAME>
#define GOG_DATA_ALLOCATOR_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_INTERFACE ((o), GOG_DATA_ALLOCATOR_TYPE, GogDataAllocatorClass))
</MACRO>
<FUNCTION>
<NAME>gog_data_allocator_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_data_allocator_allocate</NAME>
<RETURNS>void	 </RETURNS>
GogDataAllocator *dalloc, GogPlot *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_data_allocator_editor</NAME>
<RETURNS>gpointer </RETURNS>
GogDataAllocator *dalloc, GogDataset *set,int dim_i, GogDataType data_type
</FUNCTION>
<MACRO>
<NAME>GOG_SERIES_LINES_TYPE</NAME>
#define GOG_SERIES_LINES_TYPE		(gog_series_lines_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_SERIES_LINES</NAME>
#define GOG_SERIES_LINES(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_SERIES_LINES_TYPE, GogSeriesLines))
</MACRO>
<MACRO>
<NAME>IS_GOG_SERIES_LINES</NAME>
#define IS_GOG_SERIES_LINES(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_SERIES_LINES_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_series_lines_get_type</NAME>
<RETURNS>GType 	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_series_lines_render</NAME>
<RETURNS>void 	</RETURNS>
GogSeriesLines *lines, GogRenderer *rend,GogViewAllocation const *bbox, ArtVpath *path, gboolean invert
</FUNCTION>
<FUNCTION>
<NAME>gog_series_lines_use_markers</NAME>
<RETURNS>void	</RETURNS>
GogSeriesLines *lines, gboolean use_markers
</FUNCTION>
<STRUCT>
<NAME>GogPlotDesc</NAME>
struct _GogPlotDesc {
	unsigned  num_series_min, num_series_max;
	unsigned  num_axis;
	GogSeriesDesc series;
};
</STRUCT>
<STRUCT>
<NAME>GogPlot</NAME>
struct _GogPlot {
	GogObject	 base;

	GSList		*series;
	unsigned	 full_cardinality, visible_cardinality;
	gboolean	 cardinality_valid;
	unsigned	 index_num;
	gboolean	 vary_style_by_element;
	gboolean	 render_before_axes;
	gchar		*plot_group;
	char		*guru_hints;

	GOLineInterpolation	interpolation;

	GogAxis		*axis[GOG_AXIS_TYPES];

	/* Usually a copy from the class but it's here to allow a GogPlotType to
	 * override things without requiring a completely new class */
	GogPlotDesc	desc;
};
</STRUCT>
<STRUCT>
<NAME>GogPlotClass</NAME>
typedef struct {
	GogObjectClass base;

	GogPlotDesc	desc;
	GType		series_type;

	GogAxisSet	axis_set;

	/* Virtuals */

	GOData	  *(*axis_get_bounds) 	(GogPlot *plot, GogAxisType axis,
					 GogPlotBoundInfo *bounds);

	gboolean   (*supports_vary_style_by_element) (GogPlot const *plot);

	void       (*foreach_elem)    	(GogPlot *plot, gboolean only_visible,
					 GogEnumFunc handler, gpointer data);

	void       (*update_3d)		(GogPlot *plot);
	void	   (*guru_helper)	(GogPlot *plot, char const *hint);
} GogPlotClass;
</STRUCT>
<MACRO>
<NAME>GOG_PLOT_CLASS</NAME>
#define GOG_PLOT_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST ((k), GOG_PLOT_TYPE, GogPlotClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_PLOT_CLASS</NAME>
#define IS_GOG_PLOT_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_PLOT_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_PLOT_ITEM_GET_CLASS</NAME>
#define GOG_PLOT_ITEM_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_PLOT_TYPE, GogPlotClass))
</MACRO>
<MACRO>
<NAME>GOG_PLOT_VIEW_TYPE</NAME>
#define GOG_PLOT_VIEW_TYPE	(gog_plot_view_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_PLOT_VIEW</NAME>
#define GOG_PLOT_VIEW(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_PLOT_VIEW_TYPE, GogPlotView))
</MACRO>
<MACRO>
<NAME>IS_GOG_PLOT_VIEW</NAME>
#define IS_GOG_PLOT_VIEW(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_PLOT_VIEW_TYPE))
</MACRO>
<TYPEDEF>
<NAME>GogPlotView</NAME>
typedef GogView		GogPlotView;
</TYPEDEF>
<TYPEDEF>
<NAME>GogPlotViewClass</NAME>
typedef GogViewClass	GogPlotViewClass;
</TYPEDEF>
<FUNCTION>
<NAME>gog_plot_view_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogPlotBoundInfo</NAME>
typedef struct {
	struct {
		double minima, maxima;
	} val, logical;
	gboolean is_discrete;
	gboolean center_on_ticks;
	GOFormat *fmt;
} GogPlotBoundInfo;
</STRUCT>
<MACRO>
<NAME>GOG_PLOT_TYPE</NAME>
#define GOG_PLOT_TYPE	(gog_plot_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_PLOT</NAME>
#define GOG_PLOT(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_PLOT_TYPE, GogPlot))
</MACRO>
<MACRO>
<NAME>IS_GOG_PLOT</NAME>
#define IS_GOG_PLOT(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_PLOT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_plot_get_type</NAME>
<RETURNS>GType	  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_new_by_type</NAME>
<RETURNS>GogPlot  *</RETURNS>
GogPlotType const *type
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_new_by_name</NAME>
<RETURNS>GogPlot  *</RETURNS>
char const *id
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_make_similar</NAME>
<RETURNS>gboolean  </RETURNS>
GogPlot *dst, GogPlot const *src
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_request_cardinality_update</NAME>
<RETURNS>void	  </RETURNS>
GogPlot *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_update_cardinality</NAME>
<RETURNS>void 	  </RETURNS>
GogPlot *plot, int index_num
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_get_cardinality</NAME>
<RETURNS>void	  </RETURNS>
GogPlot *plot,unsigned *full, unsigned *visible
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_foreach_elem</NAME>
<RETURNS>void      </RETURNS>
GogPlot *plot, gboolean only_visible,GogEnumFunc handler, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_get_series</NAME>
<RETURNS>GSList const *</RETURNS>
GogPlot const *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_get_axis_bounds</NAME>
<RETURNS>GOData	 *</RETURNS>
GogPlot *plot, GogAxisType axis,GogPlotBoundInfo *bounds
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_supports_vary_style_by_element</NAME>
<RETURNS>gboolean  </RETURNS>
GogPlot const *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_new_series</NAME>
<RETURNS>GogSeries	  *</RETURNS>
GogPlot *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_description</NAME>
<RETURNS>GogPlotDesc const *</RETURNS>
GogPlot const *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_axis_set_pref</NAME>
<RETURNS>GogAxisSet </RETURNS>
GogPlot const *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_axis_set_is_valid</NAME>
<RETURNS>gboolean   </RETURNS>
GogPlot const *plot, GogAxisSet type
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_axis_set_assign</NAME>
<RETURNS>gboolean   </RETURNS>
GogPlot *plot, GogAxisSet type
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_axis_clear</NAME>
<RETURNS>void	   </RETURNS>
GogPlot *plot, GogAxisSet filter
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_get_axis</NAME>
<RETURNS>GogAxis	  *</RETURNS>
GogPlot const *plot, GogAxisType type
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_set_axis</NAME>
<RETURNS>void	   </RETURNS>
GogPlot *plot, GogAxis *axis
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_update_3d</NAME>
<RETURNS>void 	   </RETURNS>
GogPlot *plot
</FUNCTION>
<FUNCTION>
<NAME>gog_plot_guru_helper</NAME>
<RETURNS>void	   </RETURNS>
GogPlot *plot
</FUNCTION>
<MACRO>
<NAME>GOG_CONTROL_FOOCANVAS_TYPE</NAME>
#define GOG_CONTROL_FOOCANVAS_TYPE	(gog_control_foocanvas_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_CONTROL_FOOCANVAS</NAME>
#define GOG_CONTROL_FOOCANVAS(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_CONTROL_FOOCANVAS_TYPE, GogControlFooCanvas))
</MACRO>
<MACRO>
<NAME>IS_GOG_CONTROL_FOOCANVAS</NAME>
#define IS_GOG_CONTROL_FOOCANVAS(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_CONTROL_FOOCANVAS_TYPE))
</MACRO>
<STRUCT>
<NAME>GogControlFooCanvas</NAME>
</STRUCT>
<STRUCT>
<NAME>GogControlFooCanvas</NAME>
struct _GogControlFooCanvas {
	FooCanvasGroup	base;

	double new_h, new_w;

	GogGraph *model;
	GogRenderer *renderer;

	gboolean use_cache;
};
</STRUCT>
<TYPEDEF>
<NAME>GogControlFooCanvasClass</NAME>
typedef FooCanvasGroupClass GogControlFooCanvasClass;
</TYPEDEF>
<FUNCTION>
<NAME>gog_control_foocanvas_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogObject</NAME>
</STRUCT>
<STRUCT>
<NAME>GogObjectRole</NAME>
</STRUCT>
<STRUCT>
<NAME>GogView</NAME>
</STRUCT>
<STRUCT>
<NAME>GogGraphView</NAME>
</STRUCT>
<STRUCT>
<NAME>GogGraph</NAME>
</STRUCT>
<STRUCT>
<NAME>GogChart</NAME>
</STRUCT>
<STRUCT>
<NAME>GogPlot</NAME>
</STRUCT>
<STRUCT>
<NAME>GogPlotType</NAME>
</STRUCT>
<STRUCT>
<NAME>GogPlotFamily</NAME>
</STRUCT>
<STRUCT>
<NAME>GogPlotDesc</NAME>
</STRUCT>
<STRUCT>
<NAME>GogSeries</NAME>
</STRUCT>
<STRUCT>
<NAME>GogSeriesDesc</NAME>
</STRUCT>
<STRUCT>
<NAME>GogSeriesDimDesc</NAME>
</STRUCT>
<STRUCT>
<NAME>GogLegend</NAME>
</STRUCT>
<STRUCT>
<NAME>GogLabel</NAME>
</STRUCT>
<STRUCT>
<NAME>GogStyledObject</NAME>
</STRUCT>
<STRUCT>
<NAME>GogAxis</NAME>
</STRUCT>
<STRUCT>
<NAME>GogAxisLine</NAME>
</STRUCT>
<STRUCT>
<NAME>GogGrid</NAME>
</STRUCT>
<STRUCT>
<NAME>GogGridLine</NAME>
</STRUCT>
<STRUCT>
<NAME>GogErrorBar</NAME>
</STRUCT>
<STRUCT>
<NAME>GogRegCurve</NAME>
</STRUCT>
<STRUCT>
<NAME>GogRegEqn</NAME>
</STRUCT>
<STRUCT>
<NAME>GogTrendLineType</NAME>
</STRUCT>
<STRUCT>
<NAME>GogSeriesLines</NAME>
</STRUCT>
<STRUCT>
<NAME>GogSmoothedCurve</NAME>
</STRUCT>
<STRUCT>
<NAME>GogTheme</NAME>
</STRUCT>
<STRUCT>
<NAME>GogStyle</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GogSeriesElementStyleList</NAME>
typedef GSList 			GogSeriesElementStyleList;
</TYPEDEF>
<STRUCT>
<NAME>GogDataAllocator</NAME>
</STRUCT>
<STRUCT>
<NAME>GogDataset</NAME>
</STRUCT>
<STRUCT>
<NAME>GogRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GogViewRequisition</NAME>
typedef struct {
	double w, h;
} GogViewRequisition;
</STRUCT>
<STRUCT>
<NAME>GogViewAllocation</NAME>
typedef struct {
	double w, h;
	double x, y;
} GogViewAllocation;
</STRUCT>
<STRUCT>
<NAME>GogViewPadding</NAME>
typedef struct {
	double wr, hb;
	double wl, ht;
} GogViewPadding;
</STRUCT>
<USER_FUNCTION>
<NAME>GogEnumFunc</NAME>
<RETURNS>void </RETURNS>
unsigned i, GogStyle *style,
			     char const *name, gpointer data
</USER_FUNCTION>
<ENUM>
<NAME>GogAxisType</NAME>
typedef enum {
	GOG_AXIS_UNKNOWN = -1,
	GOG_AXIS_X	 = 0,
	GOG_AXIS_Y,
	GOG_AXIS_Z,
	GOG_AXIS_CIRCULAR,
	GOG_AXIS_RADIAL,
	GOG_AXIS_VIRTUAL,
	GOG_AXIS_PSEUDO_3D = GOG_AXIS_VIRTUAL,
	GOG_AXIS_COLOR,
	GOG_AXIS_BUBBLE,
	GOG_AXIS_TYPES
} GogAxisType;
</ENUM>
<ENUM>
<NAME>GogAxisSet</NAME>
typedef enum {
	GOG_AXIS_SET_UNKNOWN 	  = -1,
	GOG_AXIS_SET_NONE   	  = 0,
	GOG_AXIS_SET_X		  = (1 << GOG_AXIS_X),
	GOG_AXIS_SET_XY		  = (1 << GOG_AXIS_X) | (1 << GOG_AXIS_Y),
	GOG_AXIS_SET_XY_pseudo_3d = (1 << GOG_AXIS_X) | (1 << GOG_AXIS_Y) | (1 << GOG_AXIS_PSEUDO_3D),
	GOG_AXIS_SET_XY_COLOR 	  = (1 << GOG_AXIS_X) | (1 << GOG_AXIS_Y) | (1 << GOG_AXIS_COLOR),
	GOG_AXIS_SET_XY_BUBBLE 	  = (1 << GOG_AXIS_X) | (1 << GOG_AXIS_Y) | (1 << GOG_AXIS_BUBBLE),
	GOG_AXIS_SET_XYZ	  = (1 << GOG_AXIS_X) | (1 << GOG_AXIS_Y) | (1 << GOG_AXIS_Z),
	GOG_AXIS_SET_RADAR        = (1 << GOG_AXIS_CIRCULAR) | (1 << GOG_AXIS_RADIAL),
	GOG_AXIS_SET_FUNDAMENTAL  = ((1 << GOG_AXIS_VIRTUAL) - 1),
	GOG_AXIS_SET_ALL	  = ((1 << GOG_AXIS_TYPES) -1)
} GogAxisSet;
</ENUM>
<ENUM>
<NAME>GogDimType</NAME>
typedef enum {
	GOG_DIM_INVALID = -1,
	GOG_DIM_LABEL = 0,
	GOG_DIM_INDEX,
	GOG_DIM_VALUE,
	GOG_DIM_MATRIX,
	GOG_DIM_TYPES
} GogDimType;
</ENUM>
<ENUM>
<NAME>GogDataType</NAME>
typedef enum {
	GOG_DATA_SCALAR,
	GOG_DATA_VECTOR,
	GOG_DATA_MATRIX
}	GogDataType;
</ENUM>
<ENUM>
<NAME>GogMSDimType</NAME>
typedef enum {
	GOG_MS_DIM_LABELS	= 0,
	GOG_MS_DIM_VALUES	= 1,
	GOG_MS_DIM_CATEGORIES	= 2,
	GOG_MS_DIM_BUBBLES	= 3, /* undocumented */
	GOG_MS_DIM_TYPES,
	GOG_MS_DIM_ERR_plus1,	/* we made it up */
	GOG_MS_DIM_ERR_minus1,	/* we made it up */
	GOG_MS_DIM_ERR_plus2,	/* we made it up */
	GOG_MS_DIM_ERR_minus2,	/* we made it up */
	GOG_MS_DIM_START,	/* we made it up for dropbars*/
	GOG_MS_DIM_END,	/* we made it up for dropbars */
	GOG_MS_DIM_LOW,	/* we made it up for hi-lo*/
	GOG_MS_DIM_HIGH,	/* we made it up for hi-lo */
	GOG_MS_DIM_EXTRA1,	/* we made it up for other uses */
	GOG_MS_DIM_EXTRA2,	/* we made it up for other uses */
} GogMSDimType;
</ENUM>
<ENUM>
<NAME>GogObjectPosition</NAME>
typedef enum {
	GOG_POSITION_AUTO	= 0,
	GOG_POSITION_N		= 1 << 0,	/* can be used with E or W */
	GOG_POSITION_S		= 1 << 1,	/* can be used with E or W */
	GOG_POSITION_E		= 1 << 2,
	GOG_POSITION_W		= 1 << 3,
	GOG_POSITION_COMPASS	= 0x0f,

	/* modifiers for compass */
	GOG_POSITION_ALIGN_FILL	  = 0 << 4,
	GOG_POSITION_ALIGN_START  = 1 << 4,
	GOG_POSITION_ALIGN_END	  = 2 << 4,
	GOG_POSITION_ALIGN_CENTER = 3 << 4,
	GOG_POSITION_ALIGNMENT	  = 0x30,

	GOG_POSITION_SPECIAL	= 1 << 6,

	GOG_POSITION_MANUAL	  = 1 << 7,
	GOG_POSITION_MANUAL_X_ABS = 1 << 8, /* abs vs relative pos */
	GOG_POSITION_MANUAL_Y_ABS = 1 << 9,
	GOG_POSITION_MANUAL_X_END = 1 << 10, /* pos relative to start or end */
	GOG_POSITION_MANUAL_Y_END = 1 << 11,

	/* modifiers for manual */
	GOG_POSITION_ANCHOR_NW       = 0 << 12,
	GOG_POSITION_ANCHOR_N	     = 1 << 12,
	GOG_POSITION_ANCHOR_NE	     = 2 << 12,
	GOG_POSITION_ANCHOR_E        = 3 << 12,
	GOG_POSITION_ANCHOR_SE       = 4 << 12,
	GOG_POSITION_ANCHOR_S        = 5 << 12,
	GOG_POSITION_ANCHOR_SW       = 6 << 12,
	GOG_POSITION_ANCHOR_W        = 7 << 12,
	GOG_POSITION_ANCHOR_CENTER   = 8 << 12,
	GOG_POSITION_ANCHOR          = 0xf000,
	
	GOG_POSITION_ANY_MANUAL      = 0xff80,
       	
	GOG_POSITION_PADDING	     = 1 << 16
} GogObjectPosition;
</ENUM>
<MACRO>
<NAME>GOG_POSITION_IS_SPECIAL</NAME>
#define GOG_POSITION_IS_SPECIAL(pos) (((pos) & GOG_POSITION_SPECIAL)&&(!((pos) & GOG_POSITION_MANUAL)))
</MACRO>
<MACRO>
<NAME>GOG_POSITION_IS_PADDING</NAME>
#define GOG_POSITION_IS_PADDING(pos) (((pos) & GOG_POSITION_PADDING)&&(!((pos) & GOG_POSITION_MANUAL)))
</MACRO>
<MACRO>
<NAME>gog_debug</NAME>
#define gog_debug(level, code)	do { if (goffice_graph_debug_level > level) { code } } while (0)
</MACRO>
<MACRO>
<NAME>gog_debug</NAME>
#define gog_debug(level, code)
</MACRO>
<VARIABLE>
<NAME>goffice_graph_debug_level</NAME>
extern int goffice_graph_debug_level;
</VARIABLE>
<ENUM>
<NAME>GogSeriesFillType</NAME>
typedef enum {
	GOG_SERIES_FILL_TYPE_Y_ORIGIN,
	GOG_SERIES_FILL_TYPE_X_ORIGIN,
	GOG_SERIES_FILL_TYPE_BOTTOM,
	GOG_SERIES_FILL_TYPE_LEFT,
	GOG_SERIES_FILL_TYPE_TOP,
	GOG_SERIES_FILL_TYPE_RIGHT,
	GOG_SERIES_FILL_TYPE_ORIGIN,
	GOG_SERIES_FILL_TYPE_CENTER,
	GOG_SERIES_FILL_TYPE_EDGE,
	GOG_SERIES_FILL_TYPE_SELF,
	GOG_SERIES_FILL_TYPE_NEXT,
	GOG_SERIES_FILL_TYPE_INVALID
} GogSeriesFillType;
</ENUM>
<MACRO>
<NAME>GOG_SERIES_ELEMENT_TYPE</NAME>
#define GOG_SERIES_ELEMENT_TYPE	(gog_series_element_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_SERIES_ELEMENT</NAME>
#define GOG_SERIES_ELEMENT(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_SERIES_ELEMENT_TYPE, GogSeriesElement))
</MACRO>
<MACRO>
<NAME>IS_GOG_SERIES_ELEMENT</NAME>
#define IS_GOG_SERIES_ELEMENT(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_SERIES_ELEMENT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_series_element_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GOG_SERIES_TYPE</NAME>
#define GOG_SERIES_TYPE		(gog_series_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_SERIES</NAME>
#define GOG_SERIES(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_SERIES_TYPE, GogSeries))
</MACRO>
<MACRO>
<NAME>IS_GOG_SERIES</NAME>
#define IS_GOG_SERIES(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_SERIES_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_series_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_series_is_valid</NAME>
<RETURNS>gboolean      </RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_has_legend</NAME>
<RETURNS>gboolean      </RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_name</NAME>
<RETURNS>GODataScalar *</RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_plot</NAME>
<RETURNS>GogPlot	     *</RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_set_name</NAME>
<RETURNS>void	      </RETURNS>
GogSeries *series,GODataScalar *name_src, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gog_series_set_dim</NAME>
<RETURNS>void	      </RETURNS>
GogSeries *series, int dim_i,GOData *val, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gog_series_set_index</NAME>
<RETURNS>void	      </RETURNS>
GogSeries *series,int ind, gboolean is_manual
</FUNCTION>
<FUNCTION>
<NAME>gog_series_num_elements</NAME>
<RETURNS>unsigned      	  </RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_overrides</NAME>
<RETURNS>GList const  	 *</RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_xy_data</NAME>
<RETURNS>unsigned	  </RETURNS>
GogSeries const *series,double const **x,double const **y
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_xyz_data</NAME>
<RETURNS>unsigned	  </RETURNS>
GogSeries const *series,double const **x,double const **y,double const **z
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_fill_type</NAME>
<RETURNS>GogSeriesFillType </RETURNS>
GogSeries const *series
</FUNCTION>
<FUNCTION>
<NAME>gog_series_set_fill_type</NAME>
<RETURNS>void 		  </RETURNS>
GogSeries *series, GogSeriesFillType fill_type
</FUNCTION>
<FUNCTION>
<NAME>gog_series_populate_fill_type_combo</NAME>
<RETURNS>void 		  </RETURNS>
GogSeries const *series, GtkComboBox *combo
</FUNCTION>
<FUNCTION>
<NAME>gog_series_get_fill_type_from_combo</NAME>
<RETURNS>GogSeriesFillType </RETURNS>
GogSeries const *series, GtkComboBox *combo
</FUNCTION>
<TYPEDEF>
<NAME>GogTrendLine</NAME>
typedef GogStyledObject  GogTrendLine;
</TYPEDEF>
<TYPEDEF>
<NAME>GogTrendLineClass</NAME>
typedef GogStyledObjectClass GogTrendLineClass;
</TYPEDEF>
<MACRO>
<NAME>GOG_TREND_LINE_TYPE</NAME>
#define GOG_TREND_LINE_TYPE	(gog_trend_line_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_TREND_LINE</NAME>
#define GOG_TREND_LINE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_TREND_LINE_TYPE, GogTrendLine))
</MACRO>
<MACRO>
<NAME>IS_GOG_TREND_LINE</NAME>
#define IS_GOG_TREND_LINE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_TREND_LINE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_trend_line_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_trend_line_new_by_name</NAME>
<RETURNS>GogTrendLine *</RETURNS>
char const *id
</FUNCTION>
<FUNCTION>
<NAME>gog_trend_line_new_by_type</NAME>
<RETURNS>GogTrendLine *</RETURNS>
GogTrendLineType const *type
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_set_from_str</NAME>
<RETURNS>GogAxisSet </RETURNS>
char const *str
</FUNCTION>
<MACRO>
<NAME>GOG_CHART_TYPE</NAME>
#define GOG_CHART_TYPE	(gog_chart_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_CHART</NAME>
#define GOG_CHART(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_CHART_TYPE, GogChart))
</MACRO>
<MACRO>
<NAME>IS_GOG_CHART</NAME>
#define IS_GOG_CHART(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_CHART_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_chart_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_position</NAME>
<RETURNS>gboolean  </RETURNS>
GogChart const *chart, unsigned *x, unsigned *y,unsigned *cols, unsigned *rows
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_set_position</NAME>
<RETURNS>void	  </RETURNS>
GogChart *chart, unsigned int x, unsigned int y,unsigned int cols, unsigned int rows
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_plot_area</NAME>
<RETURNS>gboolean  </RETURNS>
GogChart *chart, GogViewAllocation *plot_area
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_set_plot_area</NAME>
<RETURNS>void 	  </RETURNS>
GogChart *chart, GogViewAllocation const *plot_area
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_request_cardinality_update</NAME>
<RETURNS>void	 </RETURNS>
GogChart *chart
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_cardinality</NAME>
<RETURNS>void	 </RETURNS>
GogChart *chart,unsigned *full, unsigned *visible
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_foreach_elem</NAME>
<RETURNS>void	 </RETURNS>
GogChart *chart, gboolean only_visible,GogEnumFunc handler, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_plots</NAME>
<RETURNS>GSList	*</RETURNS>
GogChart const *chart
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_axis_set</NAME>
<RETURNS>GogAxisSet </RETURNS>
GogChart const *chart
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_axis_set_is_valid</NAME>
<RETURNS>gboolean </RETURNS>
GogChart const *chart, GogAxisSet type
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_axis_set_assign</NAME>
<RETURNS>gboolean </RETURNS>
GogChart *chart, GogAxisSet type
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_axes</NAME>
<RETURNS>GSList	*</RETURNS>
GogChart const *chart, GogAxisType target
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_get_grid</NAME>
<RETURNS>GogGrid *</RETURNS>
GogChart const *chart
</FUNCTION>
<FUNCTION>
<NAME>gog_chart_view_get_plot_area</NAME>
<RETURNS>GogViewAllocation const *</RETURNS>
GogView const *view
</FUNCTION>
<STRUCT>
<NAME>GogGraph</NAME>
struct _GogGraph {
	GogOutlinedObject	 base;

	GogTheme *theme;
	GSList	 *charts;
	GSList	 *data;

	unsigned  num_cols, num_rows;
	double	  width, height;

	guint	  idle_handler;

	GHashTable *data_refs;
};
</STRUCT>
<STRUCT>
<NAME>GogGraphClass</NAME>
typedef struct {
	GogOutlinedObjectClass base;

	/* signals */
	void (*add_data)    (GogGraph *graph, GOData *input);
	void (*remove_data) (GogGraph *graph, GOData *input);
} GogGraphClass;
</STRUCT>
<MACRO>
<NAME>GOG_GRAPH_CLASS</NAME>
#define GOG_GRAPH_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GOG_GRAPH_TYPE, GogGraphClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_GRAPH_CLASS</NAME>
#define IS_GOG_GRAPH_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_GRAPH_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_graph_request_update</NAME>
<RETURNS>gboolean </RETURNS>
GogGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gog_graph_force_update</NAME>
<RETURNS>void     </RETURNS>
GogGraph *graph
</FUNCTION>
<STRUCT>
<NAME>GogAxisTickProperties</NAME>
typedef struct  {
		gboolean tick_in, tick_out;
		int size_pts;
} GogAxisTickProperties;
</STRUCT>
<STRUCT>
<NAME>GogAxisBase</NAME>
typedef struct {
	GogStyledObject	 base;

	GogChart	*chart;
	GogAxis		*axis;

	GogAxisPosition    position;
	unsigned 	   crossed_axis_id;
	GogDatasetElement  cross_location;

	int		   padding;

	GogAxisTickProperties major, minor;
	gboolean major_tick_labeled;
} GogAxisBase;
</STRUCT>
<TYPEDEF>
<NAME>GogAxisBaseClass</NAME>
typedef GogStyledObjectClass GogAxisBaseClass;
</TYPEDEF>
<MACRO>
<NAME>GOG_AXIS_BASE_TYPE</NAME>
#define GOG_AXIS_BASE_TYPE	(gog_axis_base_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_AXIS_BASE</NAME>
#define GOG_AXIS_BASE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_AXIS_BASE_TYPE, GogAxisBase))
</MACRO>
<MACRO>
<NAME>IS_GOG_AXIS_BASE</NAME>
#define IS_GOG_AXIS_BASE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_AXIS_BASE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_axis_base_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_base_get_position</NAME>
<RETURNS>GogAxisPosition 	</RETURNS>
GogAxisBase *axis_base
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_base_set_position</NAME>
<RETURNS>void		    	</RETURNS>
GogAxisBase *axis_base, GogAxisPosition position
</FUNCTION>
<FUNCTION>
<NAME>gog_axis_base_get_clamped_position</NAME>
<RETURNS>GogAxisPosition 	</RETURNS>
GogAxisBase *axis_base
</FUNCTION>
<STRUCT>
<NAME>GogAxisBaseView</NAME>
typedef struct {
	GogView		base;

	double		x_start, y_start;
	double		x_stop, y_stop;
} GogAxisBaseView;
</STRUCT>
<TYPEDEF>
<NAME>GogAxisBaseViewClass</NAME>
typedef GogViewClass	GogAxisBaseViewClass;
</TYPEDEF>
<MACRO>
<NAME>GOG_AXIS_BASE_VIEW_TYPE</NAME>
#define GOG_AXIS_BASE_VIEW_TYPE		(gog_axis_base_view_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_AXIS_BASE_VIEW</NAME>
#define GOG_AXIS_BASE_VIEW(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_AXIS_BASE_VIEW_TYPE, GogAxisBaseView))
</MACRO>
<MACRO>
<NAME>IS_GOG_AXIS_BASE_VIEW</NAME>
#define IS_GOG_AXIS_BASE_VIEW(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_AXIS_BASE_VIEW_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_axis_base_view_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogEditorPage</NAME>
typedef struct {
	char const	*label;		/* label for notebook page */
	gpointer 	 widget;	/* GtkWidget* */	
} GogEditorPage;
</STRUCT>
<STRUCT>
<NAME>GogEditor</NAME>
typedef struct {
	unsigned	*store_page;		/* pointer to a place for storing last edited page */
	GSList		*pages;			/* GogEditorPage */
	GData		*registered_widgets;
} GogEditor;
</STRUCT>
<FUNCTION>
<NAME>gog_editor_new</NAME>
<RETURNS>GogEditor	*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_editor_free</NAME>
<RETURNS>void 		 </RETURNS>
GogEditor *editor
</FUNCTION>
<FUNCTION>
<NAME>gog_editor_add_page</NAME>
<RETURNS>void		 </RETURNS>
GogEditor *editor, gpointer widget, char const *label
</FUNCTION>
<FUNCTION>
<NAME>gog_editor_set_store_page</NAME>
<RETURNS>void 		 </RETURNS>
GogEditor *editor, unsigned *store_page
</FUNCTION>
<FUNCTION>
<NAME>gog_editor_register_widget</NAME>
<RETURNS>void 		 </RETURNS>
GogEditor *editor, GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gog_editor_get_registered_widget</NAME>
<RETURNS>GtkWidget  	*</RETURNS>
GogEditor *editor, char const *name
</FUNCTION>
<FUNCTION>
<NAME>gog_editor_get_notebook</NAME>
<RETURNS>GtkWidget 	*</RETURNS>
GogEditor *editor
</FUNCTION>
<ENUM>
<NAME>GogObjectNamingConv</NAME>
typedef enum {
	GOG_OBJECT_NAME_BY_ROLE	 = 1,
	GOG_OBJECT_NAME_BY_TYPE  = 2,
	GOG_OBJECT_NAME_MANUALLY = 3
} GogObjectNamingConv;
</ENUM>
<STRUCT>
<NAME>GogObjectRole</NAME>
struct _GogObjectRole {
	char const *id;	/* for persistence */
	char const *is_a_typename;
	unsigned    priority;

	guint32		  	allowable_positions;
	GogObjectPosition 	default_position;
	GogObjectNamingConv	naming_conv;

	gboolean   (*can_add)	  (GogObject const *parent);
	gboolean   (*can_remove)  (GogObject const *child);
	GogObject *(*allocate)    (GogObject *parent);
	void	   (*post_add)    (GogObject *parent, GogObject *child);
	void       (*pre_remove)  (GogObject *parent, GogObject *child);
	void       (*post_remove) (GogObject *parent, GogObject *child);

	union { /* allow people to tack some useful tidbits on the end */
		int		i;
		float		f;
		gpointer	p;
	} user;
};
</STRUCT>
<STRUCT>
<NAME>GogObject</NAME>
struct _GogObject {
	GObject		 base;

	unsigned	 id;
	char		*user_name;	/* user assigned, NULL will fall back to system generated */
	char		*auto_name;	/* system generated, in current locale */
	
	GogObjectRole const *role;

	GogObject	*parent;
	GSList		*children;

	GogObjectPosition  position;
	GogViewAllocation  manual_position;

	unsigned needs_update : 1;
	unsigned being_updated : 1;
	unsigned explicitly_typed_role : 1; /* did we create it automaticly */
	unsigned invisible : 1;
};
</STRUCT>
<STRUCT>
<NAME>GogObjectClass</NAME>
typedef struct {
	GObjectClass	base;

	GHashTable *roles;
	GType	    view_type;

	unsigned use_parent_as_proxy : 1; /* when we change, pretend it was our parent */
	unsigned can_manual_size : 1; 
	unsigned roles_allocated : 1;

	/* Virtuals */
	void	     (*update)		(GogObject *obj);
	void	     (*parent_changed)	(GogObject *obj, gboolean was_set);
	char const  *(*type_name)	(GogObject const *obj);
	void	     (*populate_editor)	(GogObject *obj, 
					 GogEditor *editor,
					 GogDataAllocator *dalloc, 
					 GOCmdContext *cc);

	/* signals */
	void (*changed)		(GogObject *obj, gboolean size);
	void (*name_changed)	(GogObject *obj);
	void (*possible_additions_changed) (GogObject const *obj);
	void (*child_added)	   (GogObject *parent, GogObject *child);
	void (*child_removed)	   (GogObject *parent, GogObject *child);
	void (*child_name_changed) (GogObject const *obj, GogObject const *child);
	void (*children_reordered) (GogObject *obj);
	void (*update_editor)	   (GogObject *obj);
} GogObjectClass;
</STRUCT>
<MACRO>
<NAME>GOG_OBJECT_TYPE</NAME>
#define GOG_OBJECT_TYPE		(gog_object_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_OBJECT</NAME>
#define GOG_OBJECT(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_OBJECT_TYPE, GogObject))
</MACRO>
<MACRO>
<NAME>IS_GOG_OBJECT</NAME>
#define IS_GOG_OBJECT(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_OBJECT_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_OBJECT_CLASS</NAME>
#define GOG_OBJECT_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GOG_OBJECT_TYPE, GogObjectClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_OBJECT_CLASS</NAME>
#define IS_GOG_OBJECT_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_OBJECT_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_OBJECT_GET_CLASS</NAME>
#define GOG_OBJECT_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_OBJECT_TYPE, GogObjectClass))
</MACRO>
<MACRO>
<NAME>GOG_PARAM_PERSISTENT</NAME>
#define GOG_PARAM_PERSISTENT	(1 << (G_PARAM_USER_SHIFT+0))
</MACRO>
<MACRO>
<NAME>GOG_PARAM_FORCE_SAVE</NAME>
#define GOG_PARAM_FORCE_SAVE	(1 << (G_PARAM_USER_SHIFT+1))	/* even if the value == default */
</MACRO>
<MACRO>
<NAME>GOG_PARAM_POSITION</NAME>
#define GOG_PARAM_POSITION	(1 << (G_PARAM_USER_SHIFT+2))	/* position parameters */
</MACRO>
<FUNCTION>
<NAME>gog_object_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>GogDataDuplicator</NAME>
<RETURNS>void </RETURNS>
GogDataset const *src, GogDataset *dst
</USER_FUNCTION>
<FUNCTION>
<NAME>gog_object_dup</NAME>
<RETURNS>GogObject   *</RETURNS>
GogObject const *src, GogObject *new_parent, GogDataDuplicator datadup
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_parent</NAME>
<RETURNS>GogObject   *</RETURNS>
GogObject const *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_parent_typed</NAME>
<RETURNS>GogObject   *</RETURNS>
GogObject const *obj, GType t
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_graph</NAME>
<RETURNS>GogGraph    *</RETURNS>
GogObject const *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_theme</NAME>
<RETURNS>GogTheme    *</RETURNS>
GogObject const *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_id</NAME>
<RETURNS>unsigned     </RETURNS>
GogObject const *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_name</NAME>
<RETURNS>char const  *</RETURNS>
GogObject const *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_set_name</NAME>
<RETURNS>void	     </RETURNS>
GogObject *obj, char *name, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_children</NAME>
<RETURNS>GSList      *</RETURNS>
GogObject const *obj, GogObjectRole const *filter
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_child_by_role</NAME>
<RETURNS>GogObject   *</RETURNS>
GogObject const *obj, GogObjectRole const *role
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_child_by_name</NAME>
<RETURNS>GogObject   *</RETURNS>
GogObject const *obj, char const *name
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_editor</NAME>
<RETURNS>gpointer     </RETURNS>
GogObject *obj,GogDataAllocator *dalloc, GOCmdContext *cc
</FUNCTION>
<FUNCTION>
<NAME>gog_object_new_view</NAME>
<RETURNS>GogView	  *</RETURNS>
GogObject const *obj, GogView *parent
</FUNCTION>
<FUNCTION>
<NAME>gog_object_is_deletable</NAME>
<RETURNS>gboolean   </RETURNS>
GogObject const *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_possible_additions</NAME>
<RETURNS>GSList    *</RETURNS>
GogObject const *parent
</FUNCTION>
<FUNCTION>
<NAME>gog_object_add_by_role</NAME>
<RETURNS>GogObject *</RETURNS>
GogObject *parent,GogObjectRole const *role, GogObject *child
</FUNCTION>
<FUNCTION>
<NAME>gog_object_add_by_name</NAME>
<RETURNS>GogObject   *</RETURNS>
GogObject *parent,char const *role, GogObject *child
</FUNCTION>
<FUNCTION>
<NAME>gog_object_can_reorder</NAME>
<RETURNS>void		  </RETURNS>
GogObject const *obj,gboolean *inc_ok, gboolean *dec_ok
</FUNCTION>
<FUNCTION>
<NAME>gog_object_reorder</NAME>
<RETURNS>GogObject	 *</RETURNS>
GogObject const *obj,gboolean inc, gboolean goto_max
</FUNCTION>
<MACRO>
<NAME>gog_object_is_visible</NAME>
#define	  gog_object_is_visible(obj) (!((GogObject*)obj)->invisible)
</MACRO>
<FUNCTION>
<NAME>gog_object_set_invisible</NAME>
<RETURNS>void		  </RETURNS>
GogObject *obj, gboolean invisible
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_position_flags</NAME>
<RETURNS>GogObjectPosition </RETURNS>
GogObject const *obj, GogObjectPosition mask
</FUNCTION>
<FUNCTION>
<NAME>gog_object_set_position_flags</NAME>
<RETURNS>gboolean          </RETURNS>
GogObject *obj, GogObjectPosition flags,GogObjectPosition mask
</FUNCTION>
<FUNCTION>
<NAME>gog_object_is_default_position_flags</NAME>
<RETURNS>gboolean 	  </RETURNS>
GogObject const *obj, char const *name
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_manual_position</NAME>
<RETURNS>void	          </RETURNS>
GogObject *obj, GogViewAllocation *pos
</FUNCTION>
<FUNCTION>
<NAME>gog_object_set_manual_position</NAME>
<RETURNS>void 		  </RETURNS>
GogObject *obj, GogViewAllocation const *pos
</FUNCTION>
<FUNCTION>
<NAME>gog_object_get_manual_allocation</NAME>
<RETURNS>GogViewAllocation </RETURNS>
GogObject *gobj,GogViewAllocation const *parent_allocation,GogViewRequisition const *requisition
</FUNCTION>
<FUNCTION>
<NAME>gog_object_find_role_by_name</NAME>
<RETURNS>GogObjectRole const *</RETURNS>
GogObject const *obj,char const *role
</FUNCTION>
<FUNCTION>
<NAME>gog_object_update</NAME>
<RETURNS>void	 </RETURNS>
GogObject *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_request_update</NAME>
<RETURNS>gboolean </RETURNS>
GogObject *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_emit_changed</NAME>
<RETURNS>void 	 </RETURNS>
GogObject *obj, gboolean size
</FUNCTION>
<FUNCTION>
<NAME>gog_object_clear_parent</NAME>
<RETURNS>gboolean </RETURNS>
GogObject *obj
</FUNCTION>
<FUNCTION>
<NAME>gog_object_set_parent</NAME>
<RETURNS>gboolean </RETURNS>
GogObject *child, GogObject *parent,GogObjectRole const *role, unsigned int id
</FUNCTION>
<FUNCTION>
<NAME>gog_object_register_roles</NAME>
<RETURNS>void 	 </RETURNS>
GogObjectClass *klass,GogObjectRole const *roles, unsigned int n_roles
</FUNCTION>
<FUNCTION>
<NAME>gog_object_request_editor_update</NAME>
<RETURNS>void 	 </RETURNS>
GogObject *obj
</FUNCTION>
<STRUCT>
<NAME>GogStyledObject</NAME>
struct _GogStyledObject {
	GogObject	base;

	GogStyle	*style;
};
</STRUCT>
<STRUCT>
<NAME>GogStyledObjectClass</NAME>
typedef struct {
	GogObjectClass base;

	/* virtual */
	void	  (*init_style)     	(GogStyledObject *obj, GogStyle *style);

	/* signal */
	void (*style_changed) (GogStyledObject *obj, GogStyle const *new_style);
} GogStyledObjectClass;
</STRUCT>
<MACRO>
<NAME>GOG_STYLED_OBJECT_TYPE</NAME>
#define GOG_STYLED_OBJECT_TYPE	(gog_styled_object_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_STYLED_OBJECT</NAME>
#define GOG_STYLED_OBJECT(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_STYLED_OBJECT_TYPE, GogStyledObject))
</MACRO>
<MACRO>
<NAME>IS_GOG_STYLED_OBJECT</NAME>
#define IS_GOG_STYLED_OBJECT(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_STYLED_OBJECT_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_STYLED_OBJECT_GET_CLASS</NAME>
#define GOG_STYLED_OBJECT_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_STYLED_OBJECT_TYPE, GogStyledObjectClass))
</MACRO>
<FUNCTION>
<NAME>gog_styled_object_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_styled_object_set_style</NAME>
<RETURNS>gboolean  </RETURNS>
GogStyledObject *gso, GogStyle *style
</FUNCTION>
<FUNCTION>
<NAME>gog_styled_object_get_style</NAME>
<RETURNS>GogStyle *</RETURNS>
GogStyledObject *gso
</FUNCTION>
<FUNCTION>
<NAME>gog_styled_object_get_auto_style</NAME>
<RETURNS>GogStyle *</RETURNS>
GogStyledObject *gso
</FUNCTION>
<FUNCTION>
<NAME>gog_styled_object_style_changed</NAME>
<RETURNS>void	  </RETURNS>
GogStyledObject *gso
</FUNCTION>
<FUNCTION>
<NAME>gog_styled_object_apply_theme</NAME>
<RETURNS>void	  </RETURNS>
GogStyledObject *gso, GogStyle *style
</FUNCTION>
<STRUCT>
<NAME>GogToolAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GogTool</NAME>
typedef struct {
	char const 	*name;

	/* GdkCursorType	 cursor_type; Not compatible with --without-gtk */
	int	 	cursor_type;
	
	gboolean 	(*point) 	(GogView *view, double x, double y, GogObject **object);
	void 		(*render)	(GogView *view);
	void 		(*init)		(GogToolAction *action);
	void 		(*move)		(GogToolAction *action, double x, double y);
	void		(*double_click)	(GogToolAction *action);
	void 		(*destroy)	(GogToolAction *action);
} GogTool;
</STRUCT>
<STRUCT>
<NAME>GogToolAction</NAME>
struct _GogToolAction {
	double 		 start_x, start_y;
	GogView 	*view;
	GogTool 	*tool;
	gpointer	 data;
};
</STRUCT>
<FUNCTION>
<NAME>gog_tool_action_new</NAME>
<RETURNS>GogToolAction 	*</RETURNS>
GogView *view, GogTool *tool, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>gog_tool_action_move</NAME>
<RETURNS>void 		 </RETURNS>
GogToolAction *action, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>gog_tool_action_double_click</NAME>
<RETURNS>void 		 </RETURNS>
GogToolAction *action
</FUNCTION>
<FUNCTION>
<NAME>gog_tool_action_free</NAME>
<RETURNS>void 		 </RETURNS>
GogToolAction *action
</FUNCTION>
<STRUCT>
<NAME>GogView</NAME>
struct _GogView {
	GObject	 base;

	GogObject *model;

	GogRenderer *renderer;  /* not NULL */
	GogView	    *parent;	/* potentially NULL */
	GSList	    *children;

	GogViewAllocation  allocation;	/* in renderer units */
	GogViewAllocation  residual;	/* left over after compass children are placed */
	unsigned allocation_valid : 1;  /* adjust our layout when child changes size */
	unsigned child_allocations_valid : 1;  /* some children need to adjust their layout */
	unsigned being_updated : 1;

	GSList	*toolkit; 	/* List of GogTool */
};
</STRUCT>
<STRUCT>
<NAME>GogViewClass</NAME>
typedef struct {
	GObjectClass	base;

	unsigned clip : 1; 	/* Automaticaly clip to object bounding box */

	/* Virtuals */
	void	 (*state_init)    (GogView *);
	void	 (*padding_request) 		(GogView *view, GogViewAllocation const *bbox, 
						 GogViewPadding *padding);
	void	 (*size_request)    		(GogView *view, GogViewRequisition const *available, 
						 GogViewRequisition *req);
	void	 (*size_allocate)   		(GogView *, GogViewAllocation const *bbox);
	
	void	 (*render)        		(GogView *view, GogViewAllocation const *bbox);

	void	 (*build_toolkit)		(GogView *view);
} GogViewClass;
</STRUCT>
<MACRO>
<NAME>GOG_VIEW_TYPE</NAME>
#define GOG_VIEW_TYPE		(gog_view_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_VIEW</NAME>
#define GOG_VIEW(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_VIEW_TYPE, GogView))
</MACRO>
<MACRO>
<NAME>IS_GOG_VIEW</NAME>
#define IS_GOG_VIEW(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_VIEW_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_VIEW_CLASS</NAME>
#define GOG_VIEW_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GOG_VIEW_TYPE, GogViewClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_VIEW_CLASS</NAME>
#define IS_GOG_VIEW_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_VIEW_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_VIEW_GET_CLASS</NAME>
#define GOG_VIEW_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GOG_VIEW_TYPE, GogViewClass))
</MACRO>
<FUNCTION>
<NAME>gog_view_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_view_get_model</NAME>
<RETURNS>GogObject *</RETURNS>
GogView const *view
</FUNCTION>
<FUNCTION>
<NAME>gog_view_render</NAME>
<RETURNS>void	   </RETURNS>
GogView *view, GogViewAllocation const *bbox
</FUNCTION>
<FUNCTION>
<NAME>gog_view_queue_redraw</NAME>
<RETURNS>void       </RETURNS>
GogView *view
</FUNCTION>
<FUNCTION>
<NAME>gog_view_queue_resize</NAME>
<RETURNS>void       </RETURNS>
GogView *view
</FUNCTION>
<FUNCTION>
<NAME>gog_view_padding_request</NAME>
<RETURNS>void	   </RETURNS>
GogView *view, GogViewAllocation const *bbox, GogViewPadding *padding
</FUNCTION>
<FUNCTION>
<NAME>gog_view_size_request</NAME>
<RETURNS>void       </RETURNS>
GogView *view, GogViewRequisition const *available,GogViewRequisition *requisition
</FUNCTION>
<FUNCTION>
<NAME>gog_view_size_allocate</NAME>
<RETURNS>void       </RETURNS>
GogView *view, GogViewAllocation const *allocation
</FUNCTION>
<FUNCTION>
<NAME>gog_view_update_sizes</NAME>
<RETURNS>gboolean   </RETURNS>
GogView *view
</FUNCTION>
<FUNCTION>
<NAME>gog_view_find_child_view</NAME>
<RETURNS>GogView   *</RETURNS>
GogView const *container,GogObject const *target_model
</FUNCTION>
<FUNCTION>
<NAME>gog_view_get_toolkit</NAME>
<RETURNS>GSList const	*</RETURNS>
GogView *view
</FUNCTION>
<FUNCTION>
<NAME>gog_view_render_toolkit</NAME>
<RETURNS>void 		 </RETURNS>
GogView *view
</FUNCTION>
<FUNCTION>
<NAME>gog_view_get_tool_at_point</NAME>
<RETURNS>GogTool		*</RETURNS>
GogView *view, double x, double y,GogObject **gobj
</FUNCTION>
<FUNCTION>
<NAME>gog_view_get_view_at_point</NAME>
<RETURNS>GogView 	*</RETURNS>
GogView *view, double x, double y,GogObject **obj, GogTool **tool
</FUNCTION>
<FUNCTION>
<NAME>gog_view_size_child_request</NAME>
<RETURNS>void </RETURNS>
GogView *view,GogViewRequisition const *available,GogViewRequisition *req,GogViewRequisition *min_req
</FUNCTION>
<STRUCT>
<NAME>GogPersist</NAME>
</STRUCT>
<STRUCT>
<NAME>GogPersistClass</NAME>
typedef struct {
	GTypeInterface base;

	gboolean (*dom_load) (GogPersist *gp, xmlNode *node);
	void	 (*prep_sax) (GogPersist *gp, GsfXMLIn *xin, xmlChar const **attrs);
	void     (*sax_save) (GogPersist const *gp, GsfXMLOut *output);
} GogPersistClass;
</STRUCT>
<MACRO>
<NAME>GOG_PERSIST_TYPE</NAME>
#define GOG_PERSIST_TYPE	 (gog_persist_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_PERSIST</NAME>
#define GOG_PERSIST(o)		 (G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_PERSIST_TYPE, GogPersist))
</MACRO>
<MACRO>
<NAME>IS_GOG_PERSIST</NAME>
#define IS_GOG_PERSIST(o)	 (G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_PERSIST_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_PERSIST_CLASS</NAME>
#define GOG_PERSIST_CLASS(k)	 (G_TYPE_CHECK_CLASS_CAST ((k), GOG_PERSIST_TYPE, GogPersistClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_PERSIST_CLASS</NAME>
#define IS_GOG_PERSIST_CLASS(k)	 (G_TYPE_CHECK_CLASS_TYPE ((k), GOG_PERSIST_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_PERSIST_GET_CLASS</NAME>
#define GOG_PERSIST_GET_CLASS(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), GOG_PERSIST_TYPE, GogPersistClass))
</MACRO>
<FUNCTION>
<NAME>gog_persist_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_persist_dom_load</NAME>
<RETURNS>gboolean </RETURNS>
GogPersist *gp, xmlNode *node
</FUNCTION>
<FUNCTION>
<NAME>gog_persist_sax_save</NAME>
<RETURNS>void     </RETURNS>
GogPersist const *gp, GsfXMLOut *output
</FUNCTION>
<FUNCTION>
<NAME>gog_persist_prep_sax</NAME>
<RETURNS>void	 </RETURNS>
GogPersist *gp,GsfXMLIn *xin, xmlChar const **attrs
</FUNCTION>
<FUNCTION>
<NAME>gog_object_set_arg</NAME>
<RETURNS>void	   </RETURNS>
char const *name, char const *val, GogObject *obj
</FUNCTION>
<FUNCTION>
<NAME>go_xml_out_add_color</NAME>
<RETURNS>void	   </RETURNS>
GsfXMLOut *out, char const *id, GOColor c
</FUNCTION>
<FUNCTION>
<NAME>gog_object_write_xml_sax</NAME>
<RETURNS>void	   </RETURNS>
GogObject const *obj, GsfXMLOut *output
</FUNCTION>
<FUNCTION>
<NAME>gog_object_new_from_xml</NAME>
<RETURNS>GogObject *</RETURNS>
GogObject *parent, xmlNode *node
</FUNCTION>
<USER_FUNCTION>
<NAME>GogObjectSaxHandler</NAME>
<RETURNS>void </RETURNS>
GogObject *obj, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gog_object_sax_push_parser</NAME>
<RETURNS>void	   </RETURNS>
GsfXMLIn *xin, xmlChar const **attrs,GogObjectSaxHandler	handler,gpointer			user_data
</FUNCTION>
<FUNCTION>
<NAME>gog_xml_read_state_get_obj</NAME>
<RETURNS>GogObject *</RETURNS>
GsfXMLIn *xin
</FUNCTION>
<STRUCT>
<NAME>GogChart</NAME>
struct _GogChart {
	GogOutlinedObject	 base;

	GSList  *plots;
	unsigned full_cardinality, visible_cardinality;
	gboolean cardinality_valid;

	/* use a simple grid layout to position charts within graph */
	unsigned x, y, cols, rows;

	GogObject *grid;
	GSList  *axes;
	GogAxisSet axis_set;

	GogViewAllocation plot_area;
	gboolean	  is_plot_area_manual;
};
</STRUCT>
<TYPEDEF>
<NAME>GogChartClass</NAME>
typedef GogOutlinedObjectClass GogChartClass;
</TYPEDEF>
<MACRO>
<NAME>GOG_CHART_CLASS</NAME>
#define GOG_CHART_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST ((k), GOG_CHART_TYPE, GogChartClass))
</MACRO>
<MACRO>
<NAME>IS_GOG_CHART_CLASS</NAME>
#define IS_GOG_CHART_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GOG_CHART_TYPE))
</MACRO>
<MACRO>
<NAME>GOG_THEME_TYPE</NAME>
#define GOG_THEME_TYPE	(gog_theme_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_THEME</NAME>
#define GOG_THEME(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GOG_THEME_TYPE, GogTheme))
</MACRO>
<MACRO>
<NAME>IS_GOG_THEME</NAME>
#define IS_GOG_THEME(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GOG_THEME_TYPE))
</MACRO>
<FUNCTION>
<NAME>gog_theme_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_new</NAME>
<RETURNS>GogTheme   *</RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_new_from_file</NAME>
<RETURNS>GogTheme   *</RETURNS>
char const *name, char const *file
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_get_name</NAME>
<RETURNS>char const *</RETURNS>
GogTheme const *theme
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_fillin_style</NAME>
<RETURNS>void 	    </RETURNS>
GogTheme const *theme, GogStyle *style,GogObject const *obj, int ind,gboolean complete_overwrite
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_registry_add</NAME>
<RETURNS>void	    </RETURNS>
GogTheme *theme, gboolean is_default
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_registry_lookup</NAME>
<RETURNS>GogTheme   *</RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>gog_theme_registry_get_theme_names</NAME>
<RETURNS>GSList	   *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_themes_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_themes_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GogChildButton</NAME>
</STRUCT>
<STRUCT>
<NAME>GogChildButtonClass</NAME>
</STRUCT>
<MACRO>
<NAME>GOG_TYPE_CHILD_BUTTON</NAME>
#define GOG_TYPE_CHILD_BUTTON		 (gog_child_button_get_type ())
</MACRO>
<MACRO>
<NAME>GOG_CHILD_BUTTON</NAME>
#define GOG_CHILD_BUTTON(obj)		 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOG_TYPE_CHILD_BUTTON, GogChildButton))
</MACRO>
<MACRO>
<NAME>GOG_CHILD_BUTTON_CLASS</NAME>
#define GOG_CHILD_BUTTON_CLASS(klass)	 (G_TYPE_CHECK_CLASS_CAST ((klass), GOG_TYPE_CHILD_BUTTON, GogChildButtonClass))
</MACRO>
<MACRO>
<NAME>GOG_IS_CHILD_BUTTON</NAME>
#define GOG_IS_CHILD_BUTTON(obj)	 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOG_TYPE_CHILD_BUTTON))
</MACRO>
<MACRO>
<NAME>GOG_IS_CHILD_BUTTON_CLASS</NAME>
#define GOG_IS_CHILD_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOG_TYPE_CHILD_BUTTON))
</MACRO>
<MACRO>
<NAME>GOG_CHILD_BUTTON_GET_CLASS</NAME>
#define GOG_CHILD_BUTTON_GET_CLASS(obj)	 (G_TYPE_INSTANCE_GET_CLASS ((obj), GOG_TYPE_CHILD_BUTTON, GogChildButtonClass))
</MACRO>
<FUNCTION>
<NAME>gog_child_button_get_type</NAME>
<RETURNS>GType		 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_child_button_new</NAME>
<RETURNS>GtkWidget	*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gog_child_button_set_object</NAME>
<RETURNS>void 		 </RETURNS>
GogChildButton *child_button, GogObject *gog_object
</FUNCTION>
<MACRO>
<NAME>GO_DATA_TYPE</NAME>
#define GO_DATA_TYPE	(go_data_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA</NAME>
#define GO_DATA(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_TYPE, GOData))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA</NAME>
#define IS_GO_DATA(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_data_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_dup</NAME>
<RETURNS>GOData	 *</RETURNS>
GOData const *src
</FUNCTION>
<FUNCTION>
<NAME>go_data_eq</NAME>
<RETURNS>gboolean  </RETURNS>
GOData const *a, GOData const *b
</FUNCTION>
<FUNCTION>
<NAME>go_data_preferred_fmt</NAME>
<RETURNS>GOFormat *</RETURNS>
GOData const *dat
</FUNCTION>
<FUNCTION>
<NAME>go_data_as_str</NAME>
<RETURNS>char     *</RETURNS>
GOData const *dat
</FUNCTION>
<FUNCTION>
<NAME>go_data_from_str</NAME>
<RETURNS>gboolean  </RETURNS>
GOData *dat, char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_data_emit_changed</NAME>
<RETURNS>void	  </RETURNS>
GOData *dat
</FUNCTION>
<MACRO>
<NAME>GO_DATA_SCALAR_TYPE</NAME>
#define GO_DATA_SCALAR_TYPE	(go_data_scalar_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_SCALAR</NAME>
#define GO_DATA_SCALAR(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_SCALAR_TYPE, GODataScalar))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_SCALAR</NAME>
#define IS_GO_DATA_SCALAR(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_SCALAR_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_data_scalar_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_scalar_get_value</NAME>
<RETURNS>double      </RETURNS>
GODataScalar *val
</FUNCTION>
<FUNCTION>
<NAME>go_data_scalar_get_str</NAME>
<RETURNS>char const *</RETURNS>
GODataScalar *val
</FUNCTION>
<MACRO>
<NAME>GO_DATA_VECTOR_TYPE</NAME>
#define GO_DATA_VECTOR_TYPE	(go_data_vector_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_VECTOR</NAME>
#define GO_DATA_VECTOR(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_VECTOR_TYPE, GODataVector))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_VECTOR</NAME>
#define IS_GO_DATA_VECTOR(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_VECTOR_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_data_vector_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_get_len</NAME>
<RETURNS>int	 </RETURNS>
GODataVector *vec
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_get_values</NAME>
<RETURNS>double	*</RETURNS>
GODataVector *vec
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_get_value</NAME>
<RETURNS>double	 </RETURNS>
GODataVector *vec, unsigned i
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_get_str</NAME>
<RETURNS>char	*</RETURNS>
GODataVector *vec, unsigned i
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_get_minmax</NAME>
<RETURNS>void	 </RETURNS>
GODataVector *vec, double *min, double *max
</FUNCTION>
<MACRO>
<NAME>GO_DATA_MATRIX_TYPE</NAME>
#define GO_DATA_MATRIX_TYPE	(go_data_matrix_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_MATRIX</NAME>
#define GO_DATA_MATRIX(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_MATRIX_TYPE, GODataMatrix))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_MATRIX</NAME>
#define IS_GO_DATA_MATRIX(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_MATRIX_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_data_matrix_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_matrix_get_size</NAME>
<RETURNS>GODataMatrixSize	 </RETURNS>
GODataMatrix *mat
</FUNCTION>
<FUNCTION>
<NAME>go_data_matrix_get_values</NAME>
<RETURNS>double	*</RETURNS>
GODataMatrix *mat
</FUNCTION>
<FUNCTION>
<NAME>go_data_matrix_get_value</NAME>
<RETURNS>double	 </RETURNS>
GODataMatrix *mat, unsigned i, unsigned j
</FUNCTION>
<FUNCTION>
<NAME>go_data_matrix_get_str</NAME>
<RETURNS>char	*</RETURNS>
GODataMatrix *mat, unsigned i, unsigned j
</FUNCTION>
<FUNCTION>
<NAME>go_data_matrix_get_minmax</NAME>
<RETURNS>void	 </RETURNS>
GODataMatrix *mat, double *min, double *max
</FUNCTION>
<STRUCT>
<NAME>GOData</NAME>
</STRUCT>
<STRUCT>
<NAME>GODataScalar</NAME>
</STRUCT>
<STRUCT>
<NAME>GODataVector</NAME>
</STRUCT>
<STRUCT>
<NAME>GODataMatrix</NAME>
</STRUCT>
<STRUCT>
<NAME>GODataMatrixSize</NAME>
typedef struct {
	int rows;	/* negative if dirty, includes missing values */
	int columns;	/* negative if dirty, includes missing values */
} GODataMatrixSize;
</STRUCT>
<MACRO>
<NAME>GO_DATA_SCALAR_VAL_TYPE</NAME>
#define GO_DATA_SCALAR_VAL_TYPE  (go_data_scalar_val_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_SCALAR_VAL</NAME>
#define GO_DATA_SCALAR_VAL(o)	 (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_SCALAR_VAL_TYPE, GODataScalarVal))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_SCALAR_VAL</NAME>
#define IS_GO_DATA_SCALAR_VAL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_SCALAR_VAL_TYPE))
</MACRO>
<STRUCT>
<NAME>GODataScalarVal</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_data_scalar_val_get_type</NAME>
<RETURNS>GType	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_scalar_val_new</NAME>
<RETURNS>GOData	*</RETURNS>
double val
</FUNCTION>
<MACRO>
<NAME>GO_DATA_SCALAR_STR_TYPE</NAME>
#define GO_DATA_SCALAR_STR_TYPE  (go_data_scalar_str_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_SCALAR_STR</NAME>
#define GO_DATA_SCALAR_STR(o)	 (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_SCALAR_STR_TYPE, GODataScalarStr))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_SCALAR_STR</NAME>
#define IS_GO_DATA_SCALAR_STR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_SCALAR_STR_TYPE))
</MACRO>
<STRUCT>
<NAME>GODataScalarStr</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_data_scalar_str_get_type</NAME>
<RETURNS>GType	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_scalar_str_new</NAME>
<RETURNS>GOData	*</RETURNS>
char const *text, gboolean needs_free
</FUNCTION>
<FUNCTION>
<NAME>go_data_scalar_str_set_str</NAME>
<RETURNS>void     </RETURNS>
GODataScalarStr *str,char const *text, gboolean needs_free
</FUNCTION>
<MACRO>
<NAME>GO_DATA_VECTOR_VAL_TYPE</NAME>
#define GO_DATA_VECTOR_VAL_TYPE  (go_data_vector_val_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_VECTOR_VAL</NAME>
#define GO_DATA_VECTOR_VAL(o)	 (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_VECTOR_VAL_TYPE, GODataVectorVal))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_VECTOR_VAL</NAME>
#define IS_GO_DATA_VECTOR_VAL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_VECTOR_VAL_TYPE))
</MACRO>
<STRUCT>
<NAME>GODataVectorVal</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_data_vector_val_get_type</NAME>
<RETURNS>GType	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_val_new</NAME>
<RETURNS>GOData	*</RETURNS>
double *val, unsigned n, GDestroyNotify   notify
</FUNCTION>
<MACRO>
<NAME>GO_DATA_VECTOR_STR_TYPE</NAME>
#define GO_DATA_VECTOR_STR_TYPE  (go_data_vector_str_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_VECTOR_STR</NAME>
#define GO_DATA_VECTOR_STR(o)	 (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_VECTOR_STR_TYPE, GODataVectorStr))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_VECTOR_STR</NAME>
#define IS_GO_DATA_VECTOR_STR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_VECTOR_STR_TYPE))
</MACRO>
<STRUCT>
<NAME>GODataVectorStr</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_data_vector_str_get_type</NAME>
<RETURNS>GType	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_str_new</NAME>
<RETURNS>GOData *</RETURNS>
char const * const *str, unsigned n, GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_str_set_translate_func</NAME>
<RETURNS>void    </RETURNS>
GODataVectorStr *vector,GOTranslateFunc  func,gpointer         data,GDestroyNotify   notify
</FUNCTION>
<FUNCTION>
<NAME>go_data_vector_str_set_translation_domain</NAME>
<RETURNS>void </RETURNS>
GODataVectorStr *vector,char const      *domain
</FUNCTION>
<MACRO>
<NAME>GO_DATA_MATRIX_VAL_TYPE</NAME>
#define GO_DATA_MATRIX_VAL_TYPE  (go_data_matrix_val_get_type ())
</MACRO>
<MACRO>
<NAME>GO_DATA_MATRIX_VAL</NAME>
#define GO_DATA_MATRIX_VAL(o)	 (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_DATA_MATRIX_VAL_TYPE, GODataMatrixVal))
</MACRO>
<MACRO>
<NAME>IS_GO_DATA_MATRIX_VAL</NAME>
#define IS_GO_DATA_MATRIX_VAL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_DATA_MATRIX_VAL_TYPE))
</MACRO>
<STRUCT>
<NAME>GODataMatrixVal</NAME>
</STRUCT>
<FUNCTION>
<NAME>go_data_matrix_val_get_type</NAME>
<RETURNS>GType	 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_data_matrix_val_new</NAME>
<RETURNS>GOData	*</RETURNS>
double *val, unsigned rows, unsigned columns, GDestroyNotify   notify
</FUNCTION>
<ENUM>
<NAME>GODataFlags</NAME>
typedef enum {
	GO_DATA_CACHE_IS_VALID =	1 << 0,
	GO_DATA_IS_EDITABLE =		1 << 1,
	GO_DATA_VECTOR_LEN_CACHED =	1 << 2,
	GO_DATA_MATRIX_SIZE_CACHED = GO_DATA_VECTOR_LEN_CACHED
} GODataFlags;
</ENUM>
<STRUCT>
<NAME>GOData</NAME>
struct _GOData {
	GObject		base;
	gint32		flags; /* dunno what to do with these yet */
};
</STRUCT>
<STRUCT>
<NAME>GODataClass</NAME>
typedef struct {
	GObjectClass base;

	GOData	  *(*dup)	    (GOData const *src);
	gboolean   (*eq)	    (GOData const *a, GOData const *b);
	GOFormat  *(*preferred_fmt) (GOData const *dat);
	char      *(*as_str)	    (GOData const *dat);
	gboolean   (*from_str)	    (GOData *dat, char const *str);
	void	   (*emit_changed)  (GOData *dat);

	/* signals */
	void (*changed)	(GOData *dat);
} GODataClass;
</STRUCT>
<STRUCT>
<NAME>GODataScalar</NAME>
struct _GODataScalar {
	GOData base;
};
</STRUCT>
<STRUCT>
<NAME>GODataScalarClass</NAME>
typedef struct {
	GODataClass base;
	double       (*get_value)  (GODataScalar *scalar);
	char const  *(*get_str)	   (GODataScalar *scalar);
/*	PangoLayout *(get_fmt_str) (GODataScalar *scalar); */
} GODataScalarClass;
</STRUCT>
<STRUCT>
<NAME>GODataVector</NAME>
struct _GODataVector {
	GOData base;

	int len;	/* negative if dirty, includes missing values */
	double *values;	/* NULL = inititialized/unsupported, nan = missing */
	double minimum, maximum;
};
</STRUCT>
<STRUCT>
<NAME>GODataVectorClass</NAME>
typedef struct {
	GODataClass base;

	void	 (*load_len)    (GODataVector *vec);
	void	 (*load_values) (GODataVector *vec);
	double	 (*get_value)   (GODataVector *vec, unsigned i);
	char	*(*get_str)	(GODataVector *vec, unsigned i);
/*	PangoLayout *(get_fmt_str)  (GODataVector *vec, unsigned i); */
} GODataVectorClass;
</STRUCT>
<STRUCT>
<NAME>GODataMatrix</NAME>
struct _GODataMatrix {
	GOData base;

	GODataMatrixSize size;	/* negative if dirty, includes missing values */
	double *values;	/* NULL = uninitialized/unsupported, nan = missing */
	double minimum, maximum;
};
</STRUCT>
<STRUCT>
<NAME>GODataMatrixClass</NAME>
typedef struct {
	GODataClass base;

	void	 (*load_size)    (GODataMatrix *vec);
	void	 (*load_values) (GODataMatrix *vec);
	double	 (*get_value)   (GODataMatrix *mat, unsigned i, unsigned j);
	char	*(*get_str)	(GODataMatrix *mat, unsigned i, unsigned j);
/*	PangoLayout *(get_fmt_str)  (GODataMatrix *mat, unsigned i, unsigned j); */
} GODataMatrixClass;
</STRUCT>
<STRUCT>
<NAME>GOComponent</NAME>
</STRUCT>
<STRUCT>
<NAME>GOComponentType</NAME>
</STRUCT>
<STRUCT>
<NAME>GOComponent</NAME>
struct _GOComponent {
	GObject parent;

	/*protected*/
	char *mime_type;
	double width, ascent, descent, height;
	double default_width, default_ascent, default_descent;
	gboolean needs_window, resizable, editable;
	char const *data;
	int length;
	GdkWindow *window;
};
</STRUCT>
<STRUCT>
<NAME>GOComponentClass</NAME>
struct _GOComponentClass {
	GObjectClass parent_class;

	GtkWindow* (*edit) (GOComponent *component);
	gboolean (*get_data) (GOComponent *component, gpointer *data, int *length,
			      void (**clearfunc) (gpointer), gpointer *user_data);
	void (*mime_type_set) (GOComponent* component);
	void (*set_data) (GOComponent *component);
	void (*set_default_size) (GOComponent* component);
	void (*set_size) (GOComponent *component);
	void (*set_window) (GOComponent *component);
	void (*render) (GOComponent *component, cairo_t *cr,
			    double width, double height);

	/* signals */
	void (*changed) (GOComponent* component);
};
</STRUCT>
<STRUCT>
<NAME>GOComponentClass</NAME>
</STRUCT>
<MACRO>
<NAME>GO_COMPONENT_TYPE</NAME>
#define GO_COMPONENT_TYPE	(go_component_get_type ())
</MACRO>
<MACRO>
<NAME>GO_COMPONENT</NAME>
#define GO_COMPONENT(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_COMPONENT_TYPE, GOComponent))
</MACRO>
<MACRO>
<NAME>IS_GO_COMPONENT</NAME>
#define IS_GO_COMPONENT(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_COMPONENT_TYPE))
</MACRO>
<MACRO>
<NAME>GOC_PARAM_PERSISTENT</NAME>
#define GOC_PARAM_PERSISTENT	(1 << (G_PARAM_USER_SHIFT+0))
</MACRO>
<FUNCTION>
<NAME>go_component_get_type</NAME>
<RETURNS>GType	  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_component_new_by_mime_type</NAME>
<RETURNS>GOComponent  *</RETURNS>
char const *mime_type
</FUNCTION>
<FUNCTION>
<NAME>go_component_set_default_size</NAME>
<RETURNS>void </RETURNS>
GOComponent *component,double width, double ascent, double descent
</FUNCTION>
<FUNCTION>
<NAME>go_component_needs_window</NAME>
<RETURNS>gboolean </RETURNS>
GOComponent *component
</FUNCTION>
<FUNCTION>
<NAME>go_component_set_window</NAME>
<RETURNS>void </RETURNS>
GOComponent *component, GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>go_component_set_data</NAME>
<RETURNS>void </RETURNS>
GOComponent *component,char const *data, int length
</FUNCTION>
<FUNCTION>
<NAME>go_component_get_data</NAME>
<RETURNS>gboolean </RETURNS>
GOComponent *component, gpointer *data, int *length,void (**clearfunc) (gpointer data), gpointer *user_data
</FUNCTION>
<FUNCTION>
<NAME>go_component_set_size</NAME>
<RETURNS>void </RETURNS>
GOComponent *component, double width, double height
</FUNCTION>
<FUNCTION>
<NAME>go_component_is_resizable</NAME>
<RETURNS>gboolean </RETURNS>
GOComponent *component
</FUNCTION>
<FUNCTION>
<NAME>go_component_is_editable</NAME>
<RETURNS>gboolean </RETURNS>
GOComponent *component
</FUNCTION>
<FUNCTION>
<NAME>go_component_edit</NAME>
<RETURNS>GtkWindow*</RETURNS>
GOComponent *component
</FUNCTION>
<FUNCTION>
<NAME>go_component_emit_changed</NAME>
<RETURNS>void </RETURNS>
GOComponent *component
</FUNCTION>
<FUNCTION>
<NAME>go_component_set_command_context</NAME>
<RETURNS>void </RETURNS>
GOCmdContext *cc
</FUNCTION>
<FUNCTION>
<NAME>go_component_get_command_context</NAME>
<RETURNS>GOCmdContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_component_render</NAME>
<RETURNS>void </RETURNS>
GOComponent *component, cairo_t *cr, double width, double height
</FUNCTION>
<ENUM>
<NAME>GOMimePriority</NAME>
typedef enum
{
	GO_MIME_PRIORITY_INVALID = -1,
	GO_MIME_PRIORITY_DISPLAY,
	GO_MIME_PRIORITY_PRINT,
	GO_MIME_PRIORITY_PARTIAL,
	GO_MIME_PRIORITY_FULL,
	GO_MIME_PRIORITY_NATIVE,
} GOMimePriority;
</ENUM>
<FUNCTION>
<NAME>go_components_get_mime_types</NAME>
<RETURNS>GSList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_components_get_priority</NAME>
<RETURNS>GOMimePriority </RETURNS>
char const *mime_type
</FUNCTION>
<FUNCTION>
<NAME>go_components_support_clipboard</NAME>
<RETURNS>gboolean </RETURNS>
char const *mime_type
</FUNCTION>
<FUNCTION>
<NAME>go_components_add_mime_type</NAME>
<RETURNS>void </RETURNS>
char *mime, GOMimePriority priority, char const *service_id
</FUNCTION>
<FUNCTION>
<NAME>go_components_set_mime_suffix</NAME>
<RETURNS>void </RETURNS>
char const *mime, char const *suffix
</FUNCTION>
<FUNCTION>
<NAME>go_components_get_mime_suffix</NAME>
<RETURNS>char const *</RETURNS>
char const *mime
</FUNCTION>
<FUNCTION>
<NAME>goc_plugin_services_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>goc_plugin_services_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>REG_OK</NAME>
#define REG_OK REG_NOERROR
</MACRO>
<STRUCT>
<NAME>GORegexp</NAME>
typedef struct {
  size_t re_nsub;
  /*< private >*/
  gboolean nosub;
  void *ppcre;
} GORegexp;
</STRUCT>
<TYPEDEF>
<NAME>GORegoff</NAME>
typedef int GORegoff;
</TYPEDEF>
<STRUCT>
<NAME>GORegmatch</NAME>
typedef struct {
  GORegoff rm_so, rm_eo;
} GORegmatch;
</STRUCT>
<FUNCTION>
<NAME>go_regcomp</NAME>
<RETURNS>int </RETURNS>
GORegexp * preg, const char *pattern, int cflags
</FUNCTION>
<FUNCTION>
<NAME>go_regexec</NAME>
<RETURNS>int </RETURNS>
const GORegexp * preg, const char *string, size_t nmatch,GORegmatch pmatch[], int eflags
</FUNCTION>
<FUNCTION>
<NAME>go_regerror</NAME>
<RETURNS>size_t </RETURNS>
int errcode, const GORegexp * preg, char *errbuf,size_t errbuf_size
</FUNCTION>
<FUNCTION>
<NAME>go_regfree</NAME>
<RETURNS>void </RETURNS>
GORegexp * preg
</FUNCTION>
<MACRO>
<NAME>GO_SEARCH_REPLACE_TYPE</NAME>
#define GO_SEARCH_REPLACE_TYPE        (go_search_replace_get_type ())
</MACRO>
<MACRO>
<NAME>GO_SEARCH_REPLACE</NAME>
#define GO_SEARCH_REPLACE(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_SEARCH_REPLACE_TYPE, GoSearchReplace))
</MACRO>
<MACRO>
<NAME>GO_IS_SEARCH_REPLACE</NAME>
#define GO_IS_SEARCH_REPLACE(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_SEARCH_REPLACE_TYPE))
</MACRO>
<STRUCT>
<NAME>GoSearchReplace</NAME>
typedef struct _GoSearchReplace {
	GObject base;

	/*< public >*/
	char *search_text;
	char *replace_text;

	GORegexp *comp_search;
	gboolean is_regexp;	/* Search text is a regular expression.  */
	gboolean ignore_case;	/* Consider "a" and "A" the same.  */
	gboolean preserve_case;	/* Like Emacs' case-replace.  */
	gboolean match_words;	/* Like grep -w.  */

	/*< private >*/
	gboolean plain_replace;
} GoSearchReplace;
</STRUCT>
<STRUCT>
<NAME>GoSearchReplaceClass</NAME>
typedef struct {
	GObjectClass g_object_class;
} GoSearchReplaceClass;
</STRUCT>
<FUNCTION>
<NAME>go_search_replace_error_quark</NAME>
<RETURNS>GQuark           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_search_replace_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_search_replace_verify</NAME>
<RETURNS>gboolean         </RETURNS>
GoSearchReplace *sr, gboolean repl, GError **err
</FUNCTION>
<FUNCTION>
<NAME>go_search_match_string</NAME>
<RETURNS>gboolean         </RETURNS>
GoSearchReplace *sr, const char *src
</FUNCTION>
<FUNCTION>
<NAME>go_search_replace_string</NAME>
<RETURNS>char *</RETURNS>
GoSearchReplace *sr, const char *src
</FUNCTION>
<FUNCTION>
<NAME>go_regexp_quote1</NAME>
<RETURNS>const char *</RETURNS>
GString *target, const char *s
</FUNCTION>
<FUNCTION>
<NAME>go_regexp_quote</NAME>
<RETURNS>void </RETURNS>
GString *target, const char *s
</FUNCTION>
<MACRO>
<NAME>GO_CAIRO_CLAMP</NAME>
#define GO_CAIRO_CLAMP(x) CLAMP((x),-15000,15000)
</MACRO>
<MACRO>
<NAME>GO_CAIRO_CLAMP_SNAP</NAME>
#define GO_CAIRO_CLAMP_SNAP(x,even) GO_CAIRO_CLAMP(even ? floor (x + .5):floor (x) + .5)
</MACRO>
<FUNCTION>
<NAME>go_cairo_emit_svg_path</NAME>
<RETURNS>void 	 </RETURNS>
cairo_t *cr, char const *path
</FUNCTION>
<FUNCTION>
<NAME>go_cairo_surface_is_vector</NAME>
<RETURNS>gboolean </RETURNS>
cairo_surface_t const *surface
</FUNCTION>
<FUNCTION>
<NAME>go_cairo_convert_data_to_pixbuf</NAME>
<RETURNS>void	 </RETURNS>
unsigned char *dst, unsigned char const *src,int width, int height, int rowstride
</FUNCTION>
<FUNCTION>
<NAME>go_cairo_convert_data_from_pixbuf</NAME>
<RETURNS>void	 </RETURNS>
unsigned char *dst, unsigned char const *src,int width, int height, int rowstride
</FUNCTION>
<FUNCTION>
<NAME>go_xml_parse_file</NAME>
<RETURNS>xmlDocPtr  </RETURNS>
const char *filename
</FUNCTION>
<FUNCTION>
<NAME>xml_node_get_cstr</NAME>
<RETURNS>xmlChar   *</RETURNS>
xmlNodePtr node, char const *name
</FUNCTION>
<FUNCTION>
<NAME>xml_node_set_cstr</NAME>
<RETURNS>void	   </RETURNS>
xmlNodePtr node, char const *name, char const *val
</FUNCTION>
<FUNCTION>
<NAME>xml_node_get_bool</NAME>
<RETURNS>gboolean   </RETURNS>
xmlNodePtr node, char const *name, gboolean *result
</FUNCTION>
<FUNCTION>
<NAME>xml_node_set_bool</NAME>
<RETURNS>void       </RETURNS>
xmlNodePtr node, char const *name, gboolean val
</FUNCTION>
<FUNCTION>
<NAME>xml_node_get_int</NAME>
<RETURNS>gboolean   </RETURNS>
xmlNodePtr node, char const *name, int *result
</FUNCTION>
<FUNCTION>
<NAME>xml_node_set_int</NAME>
<RETURNS>void       </RETURNS>
xmlNodePtr node, char const *name, int  val
</FUNCTION>
<FUNCTION>
<NAME>xml_node_get_double</NAME>
<RETURNS>gboolean   </RETURNS>
xmlNodePtr node, char const *name, double *result
</FUNCTION>
<FUNCTION>
<NAME>xml_node_set_double</NAME>
<RETURNS>void       </RETURNS>
xmlNodePtr node, char const *name, double  val, int precision
</FUNCTION>
<FUNCTION>
<NAME>xml_node_get_gocolor</NAME>
<RETURNS>gboolean   </RETURNS>
xmlNodePtr node, char const *name, GOColor *result
</FUNCTION>
<FUNCTION>
<NAME>xml_node_set_gocolor</NAME>
<RETURNS>void	   </RETURNS>
xmlNodePtr node, char const *name, GOColor  val
</FUNCTION>
<FUNCTION>
<NAME>xml_node_get_enum</NAME>
<RETURNS>gboolean   </RETURNS>
xmlNodePtr node, char const *name, GType etype, gint *val
</FUNCTION>
<FUNCTION>
<NAME>xml_node_set_enum</NAME>
<RETURNS>void       </RETURNS>
xmlNodePtr node, char const *name, GType etype, gint val
</FUNCTION>
<FUNCTION>
<NAME>e_xml_get_child_by_name</NAME>
<RETURNS>xmlNode *</RETURNS>
xmlNode const *tree, char const *name
</FUNCTION>
<FUNCTION>
<NAME>e_xml_get_child_by_name_no_lang</NAME>
<RETURNS>xmlNode *</RETURNS>
xmlNode const *tree, char const *name
</FUNCTION>
<FUNCTION>
<NAME>e_xml_get_child_by_name_by_lang</NAME>
<RETURNS>xmlNode *</RETURNS>
xmlNode const *tree, char const *name
</FUNCTION>
<MACRO>
<NAME>GO_UNDO_TYPE</NAME>
#define GO_UNDO_TYPE	    (go_undo_get_type ())
</MACRO>
<MACRO>
<NAME>GO_UNDO</NAME>
#define GO_UNDO(o)	    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_UNDO_TYPE, GOUndo))
</MACRO>
<MACRO>
<NAME>IS_GO_UNDO</NAME>
#define IS_GO_UNDO(o)	    (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_UNDO_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_undo_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GOUndo</NAME>
</STRUCT>
<STRUCT>
<NAME>GOUndoClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GOUndo</NAME>
struct _GOUndo {
	GObject base;
};
</STRUCT>
<STRUCT>
<NAME>GOUndoClass</NAME>
struct _GOUndoClass {
	GObjectClass	base;

	void (*undo) (GOUndo *u, gpointer data);
};
</STRUCT>
<FUNCTION>
<NAME>go_undo_undo</NAME>
<RETURNS>void </RETURNS>
GOUndo *u
</FUNCTION>
<FUNCTION>
<NAME>go_undo_undo_with_data</NAME>
<RETURNS>void </RETURNS>
GOUndo *u, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>go_undo_combine</NAME>
<RETURNS>GOUndo *</RETURNS>
GOUndo *a, GOUndo *b
</FUNCTION>
<MACRO>
<NAME>GO_UNDO_GROUP_TYPE</NAME>
#define GO_UNDO_GROUP_TYPE  (go_undo_group_get_type ())
</MACRO>
<MACRO>
<NAME>GO_UNDO_GROUP</NAME>
#define GO_UNDO_GROUP(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_UNDO_GROUP_TYPE, GOUndoGroup))
</MACRO>
<MACRO>
<NAME>IS_GO_UNDO_GROUP</NAME>
#define IS_GO_UNDO_GROUP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_UNDO_GROUP_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_undo_group_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GOUndoGroup</NAME>
</STRUCT>
<STRUCT>
<NAME>GOUndoGroupClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GOUndoGroup</NAME>
struct _GOUndoGroup {
	GOUndo base;
	GPtrArray *undos;
};
</STRUCT>
<STRUCT>
<NAME>GOUndoGroupClass</NAME>
struct _GOUndoGroupClass {
	GOUndoClass base;
};
</STRUCT>
<FUNCTION>
<NAME>go_undo_group_new</NAME>
<RETURNS>GOUndoGroup *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_undo_group_add</NAME>
<RETURNS>void </RETURNS>
GOUndoGroup *g, GOUndo *u
</FUNCTION>
<MACRO>
<NAME>GO_UNDO_BINARY_TYPE</NAME>
#define GO_UNDO_BINARY_TYPE  (go_undo_binary_get_type ())
</MACRO>
<MACRO>
<NAME>GO_UNDO_BINARY</NAME>
#define GO_UNDO_BINARY(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_UNDO_BINARY_TYPE, GOUndoBinary))
</MACRO>
<MACRO>
<NAME>IS_GO_UNDO_BINARY</NAME>
#define IS_GO_UNDO_BINARY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_UNDO_BINARY_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_undo_binary_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GOUndoBinary</NAME>
</STRUCT>
<STRUCT>
<NAME>GOUndoBinaryClass</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GOUndoBinaryFunc</NAME>
<RETURNS>void </RETURNS>
gpointer a, gpointer b, gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GOUndoBinary</NAME>
struct _GOUndoBinary {
	GOUndo base;
	gpointer a, b;
	GOUndoBinaryFunc undo;
	GFreeFunc disposea;
	GFreeFunc disposeb;
};
</STRUCT>
<STRUCT>
<NAME>GOUndoBinaryClass</NAME>
struct _GOUndoBinaryClass {
	GOUndoClass base;
};
</STRUCT>
<FUNCTION>
<NAME>go_undo_binary_new</NAME>
<RETURNS>GOUndo *</RETURNS>
gpointer a, gpointer b, GOUndoBinaryFunc undo,GFreeFunc fa, GFreeFunc fb
</FUNCTION>
<MACRO>
<NAME>GO_UNDO_UNARY_TYPE</NAME>
#define GO_UNDO_UNARY_TYPE  (go_undo_unary_get_type ())
</MACRO>
<MACRO>
<NAME>GO_UNDO_UNARY</NAME>
#define GO_UNDO_UNARY(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GO_UNDO_UNARY_TYPE, GOUndoUnary))
</MACRO>
<MACRO>
<NAME>IS_GO_UNDO_UNARY</NAME>
#define IS_GO_UNDO_UNARY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_UNDO_UNARY_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_undo_unary_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GOUndoUnary</NAME>
</STRUCT>
<STRUCT>
<NAME>GOUndoUnaryClass</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GOUndoUnaryFunc</NAME>
<RETURNS>void </RETURNS>
gpointer a, gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GOUndoUnary</NAME>
struct _GOUndoUnary {
	GOUndo base;
	gpointer a;
	GOUndoUnaryFunc undo;
	GFreeFunc disposea;
};
</STRUCT>
<STRUCT>
<NAME>GOUndoUnaryClass</NAME>
struct _GOUndoUnaryClass {
	GOUndoClass base;
};
</STRUCT>
<FUNCTION>
<NAME>go_undo_unary_new</NAME>
<RETURNS>GOUndo *</RETURNS>
gpointer a, GOUndoUnaryFunc undo, GFreeFunc fa
</FUNCTION>
<ENUM>
<NAME>GOFormatFamily</NAME>
typedef enum {
	GO_FORMAT_UNKNOWN	= -1,

	GO_FORMAT_GENERAL	= 0,
	GO_FORMAT_NUMBER	= 1,
	GO_FORMAT_CURRENCY	= 2,
	GO_FORMAT_ACCOUNTING	= 3,
	GO_FORMAT_DATE		= 4,
	GO_FORMAT_TIME		= 5,
	GO_FORMAT_PERCENTAGE	= 6,
	GO_FORMAT_FRACTION	= 7,
	GO_FORMAT_SCIENTIFIC	= 8,
	GO_FORMAT_TEXT		= 9,
	GO_FORMAT_SPECIAL	= 10,

	GO_FORMAT_MARKUP	= 11	/* Internal use only */
} GOFormatFamily;
</ENUM>
<ENUM>
<NAME>GOFormatNumberError</NAME>
typedef enum {
	GO_FORMAT_NUMBER_OK = 0,
	GO_FORMAT_NUMBER_INVALID_FORMAT,
	GO_FORMAT_NUMBER_DATE_ERROR
} GOFormatNumberError;
</ENUM>
<USER_FUNCTION>
<NAME>GOFormatMeasure</NAME>
<RETURNS>int </RETURNS>
const GString *str, PangoLayout *layout
</USER_FUNCTION>
<FUNCTION>
<NAME>go_format_measure_zero</NAME>
<RETURNS>int </RETURNS>
const GString *str, PangoLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>go_format_measure_pango</NAME>
<RETURNS>int </RETURNS>
const GString *str, PangoLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>go_format_measure_strlen</NAME>
<RETURNS>int </RETURNS>
const GString *str, PangoLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>go_render_general</NAME>
<RETURNS>void </RETURNS>
PangoLayout *layout, GString *str,GOFormatMeasure measure,const GOFontMetrics *metrics,double val,int col_width,gboolean unicode_minus
</FUNCTION>
<FUNCTION>
<NAME>go_render_generall</NAME>
<RETURNS>void </RETURNS>
PangoLayout *layout, GString *str,GOFormatMeasure measure,const GOFontMetrics *metrics,long double val,int col_width,gboolean unicode_minus
</FUNCTION>
<FUNCTION>
<NAME>go_format_new_from_XL</NAME>
<RETURNS>GOFormat *</RETURNS>
char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_format_new_markup</NAME>
<RETURNS>GOFormat *</RETURNS>
PangoAttrList *markup, gboolean add_ref
</FUNCTION>
<FUNCTION>
<NAME>go_format_general</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_empty</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_default_date</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_default_time</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_default_date_time</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_default_percentage</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_default_money</NAME>
<RETURNS>GOFormat *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_format_str_localize</NAME>
<RETURNS>char     *</RETURNS>
char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_format_str_delocalize</NAME>
<RETURNS>char	 *</RETURNS>
char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_format_as_XL</NAME>
<RETURNS>const char*</RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_ref</NAME>
<RETURNS>GOFormat *</RETURNS>
GOFormat *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_unref</NAME>
<RETURNS>void      </RETURNS>
GOFormat *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_invalid</NAME>
<RETURNS>gboolean  </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_general</NAME>
<RETURNS>gboolean  </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_markup</NAME>
<RETURNS>gboolean  </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_text</NAME>
<RETURNS>gboolean  </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_var_width</NAME>
<RETURNS>gboolean  </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_date</NAME>
<RETURNS>int       </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_month_before_day</NAME>
<RETURNS>int       </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_has_hour</NAME>
<RETURNS>gboolean  </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_specialize</NAME>
<RETURNS>const GOFormat *</RETURNS>
GOFormat const *fmt,double val, char type,gboolean *inhibit_minus
</FUNCTION>
<FUNCTION>
<NAME>go_format_specializel</NAME>
<RETURNS>const GOFormat *</RETURNS>
GOFormat const *fmt,long double val, char type,gboolean *inhibit_minus
</FUNCTION>
<FUNCTION>
<NAME>go_format_get_family</NAME>
<RETURNS>GOFormatFamily         </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_get_markup</NAME>
<RETURNS>const PangoAttrList *</RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_is_simple</NAME>
<RETURNS>gboolean </RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_value_gstring</NAME>
<RETURNS>GOFormatNumberError</RETURNS>
PangoLayout *layout, GString *str,const GOFormatMeasure measure,const GOFontMetrics *metrics,GOFormat const *fmt,double val, char type, const char *sval,GOColor *go_color,int col_width,GODateConventions const *date_conv,gboolean unicode_minus
</FUNCTION>
<FUNCTION>
<NAME>go_format_value</NAME>
<RETURNS>char	*</RETURNS>
GOFormat const *fmt, double val
</FUNCTION>
<FUNCTION>
<NAME>go_format_value_gstringl</NAME>
<RETURNS>GOFormatNumberError</RETURNS>
PangoLayout *layout, GString *str,const GOFormatMeasure measure,const GOFontMetrics *metrics,GOFormat const *fmt,long double val, char type, const char *sval,GOColor *go_color,int col_width,GODateConventions const *date_conv,gboolean unicode_minus
</FUNCTION>
<FUNCTION>
<NAME>go_format_valuel</NAME>
<RETURNS>char	*</RETURNS>
GOFormat const *fmt, long double val
</FUNCTION>
<FUNCTION>
<NAME>go_format_eq</NAME>
<RETURNS>gboolean </RETURNS>
GOFormat const *a, GOFormat const *b
</FUNCTION>
<FUNCTION>
<NAME>go_format_inc_precision</NAME>
<RETURNS>GOFormat *</RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_dec_precision</NAME>
<RETURNS>GOFormat *</RETURNS>
GOFormat const *fmt
</FUNCTION>
<FUNCTION>
<NAME>go_format_toggle_1000sep</NAME>
<RETURNS>GOFormat *</RETURNS>
GOFormat const *fmt
</FUNCTION>
<STRUCT>
<NAME>GOFormatCurrency</NAME>
typedef struct {
	gchar const *symbol;
	gchar const *description;
	gboolean precedes;
	gboolean has_space;
} GOFormatCurrency;
</STRUCT>
<FUNCTION>
<NAME>go_number_format_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_number_format_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_currency_date_format_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_currency_date_format_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_pango_attr_list_open_hole</NAME>
<RETURNS>void </RETURNS>
PangoAttrList *tape, guint pos, guint len
</FUNCTION>
<FUNCTION>
<NAME>go_pango_attr_list_erase</NAME>
<RETURNS>void </RETURNS>
PangoAttrList *attrs, guint pos, guint len
</FUNCTION>
<FUNCTION>
<NAME>go_pango_attr_list_unset</NAME>
<RETURNS>void </RETURNS>
PangoAttrList  *list,gint start, gint end,PangoAttrType type
</FUNCTION>
<FUNCTION>
<NAME>go_pango_attr_list_is_empty</NAME>
<RETURNS>gboolean </RETURNS>
const PangoAttrList *attrs
</FUNCTION>
<STRUCT>
<NAME>GODateConventions</NAME>
struct _GODateConventions {
	gboolean use_1904;	/* Use MacOffice 1904 based date convention,
				 * Rather than the Win32 style 1900 */
};
</STRUCT>
<FUNCTION>
<NAME>datetime_timet_to_serial_raw</NAME>
<RETURNS>double	</RETURNS>
time_t t, GODateConventions const *conv
</FUNCTION>
<FUNCTION>
<NAME>datetime_timet_to_serial</NAME>
<RETURNS>int	</RETURNS>
time_t t, GODateConventions const *conv
</FUNCTION>
<FUNCTION>
<NAME>datetime_g_to_serial</NAME>
<RETURNS>int	</RETURNS>
GDate const *date, GODateConventions const *conv
</FUNCTION>
<FUNCTION>
<NAME>datetime_serial_to_g</NAME>
<RETURNS>void	</RETURNS>
GDate *res, int serial, GODateConventions const *conv
</FUNCTION>
<FUNCTION>
<NAME>datetime_serial_to_timet</NAME>
<RETURNS>time_t	</RETURNS>
int serial, GODateConventions const *conv
</FUNCTION>
<FUNCTION>
<NAME>datetime_serial_raw_to_serial</NAME>
<RETURNS>int	</RETURNS>
double raw
</FUNCTION>
<FUNCTION>
<NAME>datetime_timet_to_seconds</NAME>
<RETURNS>int </RETURNS>
time_t t
</FUNCTION>
<FUNCTION>
<NAME>datetime_serial_raw_to_seconds</NAME>
<RETURNS>int </RETURNS>
double raw
</FUNCTION>
<FUNCTION>
<NAME>datetime_g_months_between</NAME>
<RETURNS>int </RETURNS>
GDate const *date1, GDate const *date2
</FUNCTION>
<FUNCTION>
<NAME>datetime_g_years_between</NAME>
<RETURNS>int </RETURNS>
GDate const *date1, GDate const *date2
</FUNCTION>
<FUNCTION>
<NAME>datetime_weeknum</NAME>
<RETURNS>int </RETURNS>
GDate const *date, int method
</FUNCTION>
<ENUM>
<NAME>basis_t</NAME>
typedef enum { /* see doc/fn-financial-basis.txt for details */
	BASIS_MSRB_30_360     = 0,
	BASIS_ACT_ACT         = 1,
	BASIS_ACT_360         = 2,
	BASIS_ACT_365         = 3,
	BASIS_30E_360         = 4,
	BASIS_30Ep_360        = 5,
	BASIS_MSRB_30_360_SYM = 6         /* Gnumeric extension.  */
} basis_t;
</ENUM>
<FUNCTION>
<NAME>days_between_basis</NAME>
<RETURNS>gint32  </RETURNS>
GDate const *from, GDate const *to, basis_t basis
</FUNCTION>
<STRUCT>
<NAME>GnmCouponConvention</NAME>
typedef struct {
	int	 freq;
	basis_t  basis;
	gboolean eom;
	GODateConventions const *date_conv;
} GnmCouponConvention;
</STRUCT>
<FUNCTION>
<NAME>go_coup_cd</NAME>
<RETURNS>void	  </RETURNS>
GDate *res, GDate const *settle, GDate const *mat,int freq, gboolean eom, gboolean next
</FUNCTION>
<FUNCTION>
<NAME>go_coupdays</NAME>
<RETURNS>double </RETURNS>
GDate const *settle, GDate const *mat,GnmCouponConvention const *conv
</FUNCTION>
<FUNCTION>
<NAME>go_coupdaybs</NAME>
<RETURNS>double </RETURNS>
GDate const *settle, GDate const *mat,GnmCouponConvention const *conv
</FUNCTION>
<FUNCTION>
<NAME>go_coupdaysnc</NAME>
<RETURNS>double </RETURNS>
GDate const *settle, GDate const *mat,GnmCouponConvention const *conv
</FUNCTION>
<FUNCTION>
<NAME>gnm_date_convention_base</NAME>
<RETURNS>int </RETURNS>
GODateConventions const *conv
</FUNCTION>
<FUNCTION>
<NAME>go_date_conv_from_str</NAME>
<RETURNS>const GODateConventions *</RETURNS>
const char *s
</FUNCTION>
<FUNCTION>
<NAME>go_date_conv_equal</NAME>
<RETURNS>gboolean </RETURNS>
const GODateConventions *a, const GODateConventions *b
</FUNCTION>
<FUNCTION>
<NAME>go_date_conv_translate</NAME>
<RETURNS>double </RETURNS>
double f,const GODateConventions *src,const GODateConventions *dst
</FUNCTION>
<FUNCTION>
<NAME>go_date_weekday_name</NAME>
<RETURNS>char *</RETURNS>
GDateWeekday wd, gboolean abbrev
</FUNCTION>
<FUNCTION>
<NAME>go_date_month_name</NAME>
<RETURNS>char *</RETURNS>
GDateMonth m, gboolean abbrev
</FUNCTION>
<ENUM>
<NAME>GOImageFormat</NAME>
typedef enum {
	GO_IMAGE_FORMAT_SVG,
	GO_IMAGE_FORMAT_PNG,
	GO_IMAGE_FORMAT_JPG,
	GO_IMAGE_FORMAT_PDF,
	GO_IMAGE_FORMAT_PS,
	GO_IMAGE_FORMAT_EMF,
	GO_IMAGE_FORMAT_WMF,
	GO_IMAGE_FORMAT_UNKNOWN
} GOImageFormat;
</ENUM>
<STRUCT>
<NAME>GOImageFormatInfo</NAME>
typedef struct {
	GOImageFormat format;
	char *name;
	char *desc;
	char *ext;
	gboolean has_pixbuf_saver;
	gboolean is_dpi_useful; 
	gboolean alpha_support;
} GOImageFormatInfo;
</STRUCT>
<FUNCTION>
<NAME>go_mime_to_image_format</NAME>
<RETURNS>char 	  *</RETURNS>
char const *mime_type
</FUNCTION>
<FUNCTION>
<NAME>go_image_format_to_mime</NAME>
<RETURNS>char 	  *</RETURNS>
char const *format
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_format_info</NAME>
<RETURNS>GOImageFormatInfo const *</RETURNS>
GOImageFormat format
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_format_from_name</NAME>
<RETURNS>GOImageFormat            </RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_formats_with_pixbuf_saver</NAME>
<RETURNS>GSList 			*</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GO_IMAGE_TYPE</NAME>
#define GO_IMAGE_TYPE	(go_image_get_type ())
</MACRO>
<MACRO>
<NAME>GO_IMAGE</NAME>
#define GO_IMAGE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GO_IMAGE_TYPE, GOImage))
</MACRO>
<MACRO>
<NAME>IS_GO_IMAGE</NAME>
#define IS_GO_IMAGE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GO_IMAGE_TYPE))
</MACRO>
<FUNCTION>
<NAME>go_image_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_cairo</NAME>
<RETURNS>cairo_t 	*</RETURNS>
GOImage *image
</FUNCTION>
<FUNCTION>
<NAME>go_image_create_cairo_pattern</NAME>
<RETURNS>cairo_pattern_t *</RETURNS>
GOImage *image
</FUNCTION>
<FUNCTION>
<NAME>go_image_new_from_pixbuf</NAME>
<RETURNS>GOImage 	*</RETURNS>
GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_pixbuf</NAME>
<RETURNS>GdkPixbuf 	*</RETURNS>
GOImage *image
</FUNCTION>
<FUNCTION>
<NAME>go_image_new_from_file</NAME>
<RETURNS>GOImage 	*</RETURNS>
const char *filename, GError **error
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_pixels</NAME>
<RETURNS>guint8 		*</RETURNS>
GOImage *image
</FUNCTION>
<FUNCTION>
<NAME>go_image_get_rowstride</NAME>
<RETURNS>int 		 </RETURNS>
GOImage *image
</FUNCTION>
<FUNCTION>
<NAME>go_image_fill</NAME>
<RETURNS>void 		 </RETURNS>
GOImage *image, GOColor color
</FUNCTION>
<ENUM>
<NAME>GOGradientDirection</NAME>
typedef enum {
	GO_GRADIENT_N_TO_S,
	GO_GRADIENT_S_TO_N,
	GO_GRADIENT_N_TO_S_MIRRORED,
	GO_GRADIENT_S_TO_N_MIRRORED,
	GO_GRADIENT_W_TO_E,
	GO_GRADIENT_E_TO_W,
	GO_GRADIENT_W_TO_E_MIRRORED,
	GO_GRADIENT_E_TO_W_MIRRORED,
	GO_GRADIENT_NW_TO_SE,
	GO_GRADIENT_SE_TO_NW,
	GO_GRADIENT_NW_TO_SE_MIRRORED,
	GO_GRADIENT_SE_TO_NW_MIRRORED,
	GO_GRADIENT_NE_TO_SW,
	GO_GRADIENT_SW_TO_NE,
	GO_GRADIENT_SW_TO_NE_MIRRORED,
	GO_GRADIENT_NE_TO_SW_MIRRORED,
	GO_GRADIENT_MAX
} GOGradientDirection;
</ENUM>
<FUNCTION>
<NAME>go_gradient_dir_from_str</NAME>
<RETURNS>GOGradientDirection </RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>go_gradient_dir_as_str</NAME>
<RETURNS>const gchar *</RETURNS>
GOGradientDirection dir
</FUNCTION>
<FUNCTION>
<NAME>go_gradient_setup</NAME>
<RETURNS>void </RETURNS>
ArtGradientLinear *gradient,GOGradientDirection dir, GOColor col0, GOColor col1,double x0, double y0, double x1, double y1,ArtGradientStop *stops
</FUNCTION>
<MACRO>
<NAME>PT_PER_IN</NAME>
#define PT_PER_IN 72
</MACRO>
<MACRO>
<NAME>CM_PER_IN</NAME>
#define CM_PER_IN 254
</MACRO>
<MACRO>
<NAME>EMU_PER_IN</NAME>
#define EMU_PER_IN 914400
</MACRO>
<MACRO>
<NAME>UN_PER_IN</NAME>
#define UN_PER_IN 228600000
</MACRO>
<MACRO>
<NAME>UN_PER_EMU</NAME>
#define UN_PER_EMU (UN_PER_IN/EMU_PER_IN)
</MACRO>
<MACRO>
<NAME>UN_PER_PT</NAME>
#define UN_PER_PT (UN_PER_IN/PT_PER_IN)
</MACRO>
<MACRO>
<NAME>UN_PER_CM</NAME>
#define UN_PER_CM (UN_PER_IN/CM_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_IN_TO_UN</NAME>
#define GO_IN_TO_UN(inch)	((inch)*UN_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_IN_TO_PT</NAME>
#define GO_IN_TO_PT(inch)	((inch)*PT_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_IN_TO_CM</NAME>
#define GO_IN_TO_CM(inch)	((inch)*CM_PER_IN/100)
</MACRO>
<MACRO>
<NAME>GO_IN_TO_EMU</NAME>
#define GO_IN_TO_EMU(inch)	((inch)*EMU_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_UN_TO_IN</NAME>
#define GO_UN_TO_IN(unit)	((unit)/UN_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_UN_TO_PT</NAME>
#define GO_UN_TO_PT(unit)	((unit)/UN_PER_PT)
</MACRO>
<MACRO>
<NAME>GO_UN_TO_CM</NAME>
#define GO_UN_TO_CM(unit)	((unit)/UN_PER_CM/100)
</MACRO>
<MACRO>
<NAME>GO_UN_TO_EMU</NAME>
#define GO_UN_TO_EMU(unit)	((unit)/UN_PER_EMU)
</MACRO>
<MACRO>
<NAME>GO_PT_TO_UN</NAME>
#define GO_PT_TO_UN(pt)		((pt)* UN_PER_PT)
</MACRO>
<MACRO>
<NAME>GO_PT_TO_IN</NAME>
#define GO_PT_TO_IN(pt)		((pt)           /PT_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_PT_TO_CM</NAME>
#define GO_PT_TO_CM(pt)		((pt)* CM_PER_IN/PT_PER_IN/100)
</MACRO>
<MACRO>
<NAME>GO_PT_TO_EMU</NAME>
#define GO_PT_TO_EMU(pt)	((pt)*EMU_PER_IN/PT_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_CM_TO_UN</NAME>
#define GO_CM_TO_UN(cm)		((cm)*100*UN_PER_CM)
</MACRO>
<MACRO>
<NAME>GO_CM_TO_IN</NAME>
#define GO_CM_TO_IN(cm)		((cm)*100          /CM_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_CM_TO_PT</NAME>
#define GO_CM_TO_PT(cm)		((cm)*100*PT_PER_IN/CM_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_CM_TO_EMU</NAME>
#define GO_CM_TO_EMU(cm)	((cm)*100*PT_PER_IN/EMU_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_EMU_TO_UN</NAME>
#define GO_EMU_TO_UN(emu)	((emu)*UN_PER_EMU)
</MACRO>
<MACRO>
<NAME>GO_EMU_TO_IN</NAME>
#define GO_EMU_TO_IN(emu)	((emu)          /EMU_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_EMU_TO_PT</NAME>
#define GO_EMU_TO_PT(emu)	((emu)*PT_PER_IN/EMU_PER_IN)
</MACRO>
<MACRO>
<NAME>GO_EMU_TO_CM</NAME>
#define GO_EMU_TO_CM(emu)	((emu)*CM_PER_IN/EMU_PER_IN/100)
</MACRO>
<TYPEDEF>
<NAME>GODistance</NAME>
typedef gint64 GODistance;
</TYPEDEF>
<STRUCT>
<NAME>GOPoint</NAME>
typedef struct {
	GODistance x;
	GODistance y;
} GOPoint;
</STRUCT>
<STRUCT>
<NAME>GORect</NAME>
typedef struct {
	GODistance top;
	GODistance left;
	GODistance bottom;
	GODistance right;
} GORect;
</STRUCT>
<ENUM>
<NAME>GOPathDirection</NAME>
typedef enum {
	GO_PATH_DIRECTION_FORWARD,
	GO_PATH_DIRECTION_BACKWARD
} GOPathDirection;
</ENUM>
<ENUM>
<NAME>GOPathOptions</NAME>
typedef enum {
	GO_PATH_OPTIONS_SNAP_COORDINATES 	= 1<<0,
	GO_PATH_OPTIONS_SNAP_WIDTH		= 1<<1,
	GO_PATH_OPTIONS_SHARP			= 3
} GOPathOptions;
</ENUM>
<STRUCT>
<NAME>GOPathPoint</NAME>
typedef struct {
	double x;
	double y;
} GOPathPoint;
</STRUCT>
<STRUCT>
<NAME>GOPath</NAME>
</STRUCT>
<MACRO>
<NAME>IS_GO_PATH</NAME>
#define IS_GO_PATH(x) ((x) != NULL)
</MACRO>
<FUNCTION>
<NAME>go_path_new</NAME>
<RETURNS>GOPath *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_path_clear</NAME>
<RETURNS>void 	</RETURNS>
GOPath *path
</FUNCTION>
<FUNCTION>
<NAME>go_path_free</NAME>
<RETURNS>void    </RETURNS>
GOPath *path
</FUNCTION>
<FUNCTION>
<NAME>go_path_set_options</NAME>
<RETURNS>void    	</RETURNS>
GOPath *path, GOPathOptions options
</FUNCTION>
<FUNCTION>
<NAME>go_path_get_options</NAME>
<RETURNS>GOPathOptions   </RETURNS>
GOPath const *path
</FUNCTION>
<FUNCTION>
<NAME>go_path_move_to</NAME>
<RETURNS>void 	</RETURNS>
GOPath *path, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>go_path_line_to</NAME>
<RETURNS>void 	</RETURNS>
GOPath *path, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>go_path_curve_to</NAME>
<RETURNS>void 	</RETURNS>
GOPath *path, double x0, double y0,double x1, double y1,double x2, double y2
</FUNCTION>
<FUNCTION>
<NAME>go_path_close</NAME>
<RETURNS>void 	</RETURNS>
GOPath *path
</FUNCTION>
<FUNCTION>
<NAME>go_path_ring_wedge</NAME>
<RETURNS>void 	</RETURNS>
GOPath *path, double cx, double cy,double rx_out, double ry_out,double rx_in, double ry_in,double th0, double th1
</FUNCTION>
<FUNCTION>
<NAME>go_path_pie_wedge</NAME>
<RETURNS>void    </RETURNS>
GOPath *path, double cx, double cy,double rx, double ry,double th0, double th1
</FUNCTION>
<FUNCTION>
<NAME>go_path_arc</NAME>
<RETURNS>void    </RETURNS>
GOPath *path,double cx, double cy,double rx, double ry,double th0, double th1
</FUNCTION>
<FUNCTION>
<NAME>go_path_arc_to</NAME>
<RETURNS>void    </RETURNS>
GOPath *path,double cx, double cy,double rx, double ry,double th0, double th1
</FUNCTION>
<FUNCTION>
<NAME>go_path_rectangle</NAME>
<RETURNS>void	</RETURNS>
GOPath *path, double x, double y,double width, double height
</FUNCTION>
<FUNCTION>
<NAME>go_path_interpret</NAME>
<RETURNS>void	</RETURNS>
GOPath const *path,GOPathDirection direction,GOPathMoveToFunc *move_to,GOPathLineToFunc *line_to,GOPathCurveToFunc *curve_to,GOPathClosePathFunc *close_path,void *closure
</FUNCTION>
<FUNCTION>
<NAME>go_setlocale</NAME>
<RETURNS>char const *</RETURNS>
int category, char const *val
</FUNCTION>
<FUNCTION>
<NAME>go_locale_untranslated_booleans</NAME>
<RETURNS>void	       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_boolean_name</NAME>
<RETURNS>char const *</RETURNS>
gboolean b
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_currency</NAME>
<RETURNS>GString const *</RETURNS>
gboolean *precedes, gboolean *space_sep
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_arg_sep</NAME>
<RETURNS>char           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_col_sep</NAME>
<RETURNS>char           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_row_sep</NAME>
<RETURNS>char           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_thousand</NAME>
<RETURNS>GString const *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_decimal</NAME>
<RETURNS>GString const *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_month_before_day</NAME>
<RETURNS>int            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_date_format</NAME>
<RETURNS>GString const *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_locale_get_time_format</NAME>
<RETURNS>GString const *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GO_GEOMETRY_ANGLE_TOLERANCE</NAME>
#define GO_GEOMETRY_ANGLE_TOLERANCE 1E-3
</MACRO>
<ENUM>
<NAME>GOGeometrySide</NAME>
typedef enum {
	GO_SIDE_LEFT		= 1 << 0,
	GO_SIDE_RIGHT		= 1 << 1,
	GO_SIDE_LEFT_RIGHT	= 3 << 0,
	GO_SIDE_TOP		= 1 << 2,
	GO_SIDE_BOTTOM		= 1 << 3,
	GO_SIDE_TOP_BOTTOM	= 3 << 2,
	GO_SIDE_AUTO		= 15
} GOGeometrySide;
</ENUM>
<ENUM>
<NAME>GODirection</NAME>
typedef enum {
	GO_DIRECTION_UP    = 0,	
	GO_DIRECTION_DOWN  = 1,
	GO_DIRECTION_LEFT  = 2,
	GO_DIRECTION_RIGHT = 3,
	GO_DIRECTION_NONE  = 4
} GODirection;
</ENUM>
<ENUM>
<NAME>GOGeometryRotationType</NAME>
typedef enum {
	GO_ROTATE_NONE = 0,
	GO_ROTATE_COUNTERCLOCKWISE = 1,
	GO_ROTATE_UPSIDEDOWN = 2,
	GO_ROTATE_CLOCKWISE = 3,	
	GO_ROTATE_FREE = 4
} GOGeometryRotationType;
</ENUM>
<STRUCT>
<NAME>GOGeometryOBR</NAME>
typedef struct {
        double x,y;     /* Center */
        double w,h;     /* Edges */
        double alpha;   /* Angle from x axis to w edge, in radians */
} GOGeometryOBR;
</STRUCT>
<MACRO>
<NAME>GOGeometryAABR</NAME>
#define GOGeometryAABR GogViewAllocation /* x, y: top left corner */
</MACRO>
<FUNCTION>
<NAME>go_geometry_cartesian_to_polar</NAME>
<RETURNS>void 		</RETURNS>
double x, double y, double *rho, double *theta
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_point_to_segment</NAME>
<RETURNS>double 		</RETURNS>
double xp, double yp, double xs, double ys, double w, double h
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_AABR_add</NAME>
<RETURNS>void 		</RETURNS>
GOGeometryAABR *aabr0, GOGeometryAABR const *aabr1
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_OBR_to_AABR</NAME>
<RETURNS>void		</RETURNS>
GOGeometryOBR const *obr, GOGeometryAABR *aabr
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_test_OBR_overlap</NAME>
<RETURNS>gboolean 	</RETURNS>
GOGeometryOBR const *obr0, GOGeometryOBR const *obr1
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_get_rotation_type</NAME>
<RETURNS>GOGeometryRotationType	</RETURNS>
double alpha
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_calc_label_anchor</NAME>
<RETURNS>GOGeometrySide 		</RETURNS>
GOGeometryOBR *obr, double alpha
</FUNCTION>
<FUNCTION>
<NAME>go_geometry_calc_label_position</NAME>
<RETURNS>GOGeometrySide		</RETURNS>
GOGeometryOBR *obr, double alpha, double offset,GOGeometrySide side, GOGeometrySide anchor
</FUNCTION>
<MACRO>
<NAME>GO_DIRECTION_TYPE</NAME>
#define  GO_DIRECTION_TYPE (go_direction_get_type())
</MACRO>
<FUNCTION>
<NAME>go_direction_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_direction_is_horizontal</NAME>
<RETURNS>gboolean </RETURNS>
GODirection d
</FUNCTION>
<FUNCTION>
<NAME>go_direction_is_forward</NAME>
<RETURNS>gboolean </RETURNS>
GODirection d
</FUNCTION>
<STRUCT>
<NAME>GOFilePermissions</NAME>
</STRUCT>
<STRUCT>
<NAME>GOFilePermissions</NAME>
struct _GOFilePermissions {
	gboolean owner_read;
	gboolean owner_write;
	gboolean owner_execute;

	gboolean group_read;
	gboolean group_write;
	gboolean group_execute;

	gboolean others_read;
	gboolean others_write;
	gboolean others_execute;
};
</STRUCT>
<ENUM>
<NAME>GODotDot</NAME>
typedef enum {
	GO_DOTDOT_SYNTACTIC,    /* Assume no symlinks.  */
	GO_DOTDOT_TEST,         /* Check.  */
	GO_DOTDOT_LEAVE         /* Leave alone.  */
} GODotDot;
</ENUM>
<MACRO>
<NAME>F_OK</NAME>
#  define F_OK 0
</MACRO>
<MACRO>
<NAME>X_OK</NAME>
#  define X_OK 1
</MACRO>
<MACRO>
<NAME>W_OK</NAME>
#  define W_OK 2
</MACRO>
<MACRO>
<NAME>R_OK</NAME>
#  define R_OK 4
</MACRO>
<FUNCTION>
<NAME>go_filename_simplify</NAME>
<RETURNS>char *</RETURNS>
const char *filename, GODotDot dotdot, gboolean make_absolute
</FUNCTION>
<FUNCTION>
<NAME>go_url_simplify</NAME>
<RETURNS>char *</RETURNS>
const char *uri
</FUNCTION>
<FUNCTION>
<NAME>go_filename_from_uri</NAME>
<RETURNS>char *</RETURNS>
const char *uri
</FUNCTION>
<FUNCTION>
<NAME>go_filename_to_uri</NAME>
<RETURNS>char *</RETURNS>
const char *filename
</FUNCTION>
<FUNCTION>
<NAME>go_url_resolve_relative</NAME>
<RETURNS>char *</RETURNS>
const char *ref_uri, const char *rel_uri
</FUNCTION>
<FUNCTION>
<NAME>go_url_make_relative</NAME>
<RETURNS>char *</RETURNS>
const char *uri, const char *ref_uri
</FUNCTION>
<FUNCTION>
<NAME>go_shell_arg_to_uri</NAME>
<RETURNS>char *</RETURNS>
const char *arg
</FUNCTION>
<FUNCTION>
<NAME>go_basename_from_uri</NAME>
<RETURNS>char *</RETURNS>
const char *uri
</FUNCTION>
<FUNCTION>
<NAME>go_dirname_from_uri</NAME>
<RETURNS>char *</RETURNS>
const char *uri, gboolean brief
</FUNCTION>
<FUNCTION>
<NAME>go_shell_argv_to_glib_encoding</NAME>
<RETURNS>gchar const **</RETURNS>
gint argc, gchar const **argv
</FUNCTION>
<FUNCTION>
<NAME>go_shell_argv_to_glib_encoding_free</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_file_open</NAME>
<RETURNS>GsfInput  *</RETURNS>
char const *uri, GError **err
</FUNCTION>
<FUNCTION>
<NAME>go_file_create</NAME>
<RETURNS>GsfOutput *</RETURNS>
char const *uri, GError **err
</FUNCTION>
<FUNCTION>
<NAME>go_file_split_urls</NAME>
<RETURNS>GSList	  *</RETURNS>
char const *data
</FUNCTION>
<FUNCTION>
<NAME>go_file_get_owner_name</NAME>
<RETURNS>gchar     *</RETURNS>
char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_file_get_group_name</NAME>
<RETURNS>gchar     *</RETURNS>
char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_get_file_permissions</NAME>
<RETURNS>GOFilePermissions *</RETURNS>
char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_set_file_permissions</NAME>
<RETURNS>void </RETURNS>
char const *uri, GOFilePermissions * file_permissions
</FUNCTION>
<FUNCTION>
<NAME>go_file_get_date_accessed</NAME>
<RETURNS>time_t </RETURNS>
char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_file_get_date_modified</NAME>
<RETURNS>time_t </RETURNS>
char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_file_get_date_changed</NAME>
<RETURNS>time_t </RETURNS>
char const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_file_access</NAME>
<RETURNS>gint	 </RETURNS>
char const *uri, gint mode
</FUNCTION>
<FUNCTION>
<NAME>go_url_decode</NAME>
<RETURNS>gchar	*</RETURNS>
gchar const *text
</FUNCTION>
<FUNCTION>
<NAME>go_url_encode</NAME>
<RETURNS>gchar	*</RETURNS>
gchar const *text, int type
</FUNCTION>
<FUNCTION>
<NAME>go_url_show</NAME>
<RETURNS>GError	*</RETURNS>
gchar const *url
</FUNCTION>
<FUNCTION>
<NAME>go_url_check_extension</NAME>
<RETURNS>gboolean </RETURNS>
gchar const *uri,gchar const *std_ext,gchar **new_uri
</FUNCTION>
<FUNCTION>
<NAME>go_get_mime_type</NAME>
<RETURNS>gchar	*</RETURNS>
gchar const *uri
</FUNCTION>
<FUNCTION>
<NAME>go_get_mime_type_for_data</NAME>
<RETURNS>gchar	*</RETURNS>
gconstpointer data, int data_size
</FUNCTION>
<FUNCTION>
<NAME>go_mime_type_get_description</NAME>
<RETURNS>gchar const	*</RETURNS>
gchar const *mime_type
</FUNCTION>
<STRUCT>
<NAME>GOPattern</NAME>
struct _GOPattern {
	GOColor	 fore, back;
	unsigned pattern;
};
</STRUCT>
<ENUM>
<NAME>GOPatternType</NAME>
typedef enum {
	GO_PATTERN_SOLID,
	GO_PATTERN_GREY75,
	GO_PATTERN_GREY50,
	GO_PATTERN_GREY25,
	GO_PATTERN_GREY125,
	GO_PATTERN_GREY625,
	GO_PATTERN_HORIZ,
	GO_PATTERN_VERT,
	GO_PATTERN_REV_DIAG,
	GO_PATTERN_DIAG,
	GO_PATTERN_DIAG_CROSS,
	GO_PATTERN_THICK_DIAG_CROSS,
	GO_PATTERN_THIN_HORIZ,
	GO_PATTERN_THIN_VERT,
	GO_PATTERN_THIN_REV_DIAG,
	GO_PATTERN_THIN_DIAG,
	GO_PATTERN_THIN_HORIZ_CROSS,
	GO_PATTERN_THIN_DIAG_CROSS,
	GO_PATTERN_FOREGROUND_SOLID,
	GO_PATTERN_SMALL_CIRCLES,
	GO_PATTERN_SEMI_CIRCLES,
	GO_PATTERN_THATCH,
	GO_PATTERN_LARGE_CIRCLES,
	GO_PATTERN_BRICKS,
	GO_PATTERN_MAX
} GOPatternType;
</ENUM>
<FUNCTION>
<NAME>go_pattern_from_str</NAME>
<RETURNS>GOPatternType	 </RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_as_str</NAME>
<RETURNS>char const	*</RETURNS>
GOPatternType pattern
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_is_solid</NAME>
<RETURNS>gboolean	 </RETURNS>
GOPattern const *pat, GOColor *color
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_set_solid</NAME>
<RETURNS>void		 </RETURNS>
GOPattern *pat, GOColor fore
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_get_pattern</NAME>
<RETURNS>guint8 const 	*</RETURNS>
GOPattern const *pat
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_get_svg_path</NAME>
<RETURNS>xmlChar		*</RETURNS>
GOPattern const *pattern, double *width, double *height
</FUNCTION>
<FUNCTION>
<NAME>go_pattern_create_cairo_pattern</NAME>
<RETURNS>cairo_pattern_t *</RETURNS>
GOPattern const *pattern, cairo_t *cr
</FUNCTION>
<ENUM>
<NAME>GOPathAction</NAME>
typedef enum _GOPathAction {
	GO_PATH_ACTION_MOVE_TO 		= 0,
	GO_PATH_ACTION_LINE_TO 		= 1,
	GO_PATH_ACTION_CURVE_TO 	= 2,
	GO_PATH_ACTION_CLOSE_PATH 	= 3
} GOPathAction; 
</ENUM>
<STRUCT>
<NAME>GOPathData</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPathDataBuffer</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPathData</NAME>
struct _GOPathData {
	GOPathAction action;
	GOPoint point;
};
</STRUCT>
<STRUCT>
<NAME>GOPathDataBuffer</NAME>
struct _GOPathDataBuffer {
	int max_data;
	int num_data;

	GOPathData *data;

	struct _GOPathDataBuffer *next;
};
</STRUCT>
<STRUCT>
<NAME>GOPath</NAME>
struct _GOPath {
	GOPathDataBuffer *data_buffer_head;
	GOPathDataBuffer *data_buffer_tail;

	gboolean sharp;
};
</STRUCT>
<STRUCT>
<NAME>GOFontMetrics</NAME>
struct _GOFontMetrics {
	int digit_widths[10];
	int min_digit_width;
	int max_digit_width;
	int avg_digit_width;
	int hyphen_width, minus_width, plus_width;
	int E_width;
	int hash_width;
	int space_width;

	/*
	 * A space that is narrower than a regular space, or 0 if no such
	 * character was found.
	 */
	gunichar thin_space;
	int thin_space_width;
};
</STRUCT>
<STRUCT>
<NAME>GOFont</NAME>
struct _GOFont {
	int ref_count;
	int font_index; /* each renderer keeps an array for lookup */

	PangoFontDescription *desc;

	/* Attributes.  Currently unused.  */
	int underline;
	gboolean strikethrough;
	GOColor color;
};
</STRUCT>
<FUNCTION>
<NAME>go_font_new_by_desc</NAME>
<RETURNS>GOFont const *</RETURNS>
PangoFontDescription *desc
</FUNCTION>
<FUNCTION>
<NAME>go_font_new_by_name</NAME>
<RETURNS>GOFont const *</RETURNS>
char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_font_new_by_index</NAME>
<RETURNS>GOFont const *</RETURNS>
unsigned i
</FUNCTION>
<FUNCTION>
<NAME>go_font_as_str</NAME>
<RETURNS>char   	     *</RETURNS>
GOFont const *font
</FUNCTION>
<FUNCTION>
<NAME>go_font_ref</NAME>
<RETURNS>GOFont const *</RETURNS>
GOFont const *font
</FUNCTION>
<FUNCTION>
<NAME>go_font_unref</NAME>
<RETURNS>void	      </RETURNS>
GOFont const *font
</FUNCTION>
<FUNCTION>
<NAME>go_font_eq</NAME>
<RETURNS>gboolean      </RETURNS>
GOFont const *a, GOFont const *b
</FUNCTION>
<FUNCTION>
<NAME>go_fonts_list_families</NAME>
<RETURNS>GSList       *</RETURNS>
PangoContext *context
</FUNCTION>
<FUNCTION>
<NAME>go_fonts_list_sizes</NAME>
<RETURNS>GSList       *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_font_metrics_new</NAME>
<RETURNS>GOFontMetrics *</RETURNS>
PangoContext *context, GOFont const *font
</FUNCTION>
<FUNCTION>
<NAME>go_font_metrics_free</NAME>
<RETURNS>void </RETURNS>
GOFontMetrics *metrics
</FUNCTION>
<FUNCTION>
<NAME>go_font_cache_register</NAME>
<RETURNS>void </RETURNS>
GClosure *callback
</FUNCTION>
<FUNCTION>
<NAME>go_font_cache_unregister</NAME>
<RETURNS>void </RETURNS>
GClosure *callback
</FUNCTION>
<FUNCTION>
<NAME>go_fonts_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_fonts_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GONamedColor</NAME>
typedef struct {
	GOColor		 color;
	char const 	*name;	/* english name - eg. "white" */
} GONamedColor;
</STRUCT>
<MACRO>
<NAME>GDK_TO_UINT</NAME>
#define GDK_TO_UINT(c)	RGBA_TO_UINT(((c).red>>8), ((c).green>>8), ((c).blue>>8), 0xff)
</MACRO>
<MACRO>
<NAME>RGB_TO_UINT</NAME>
#define RGB_TO_UINT(r,g,b)	((((guint)(r))<<16)|(((guint)(g))<<8)|((guint)(b)))
</MACRO>
<MACRO>
<NAME>RGB_TO_RGBA</NAME>
#define RGB_TO_RGBA(x,a)	(((x) << 8) | ((((guint)a) & 0xff)))
</MACRO>
<MACRO>
<NAME>RGB_WHITE</NAME>
#define RGB_WHITE   RGB_TO_UINT(0xff, 0xff, 0xff)
</MACRO>
<MACRO>
<NAME>RGB_BLACK</NAME>
#define RGB_BLACK   RGB_TO_UINT(0x00, 0x00, 0x00)
</MACRO>
<MACRO>
<NAME>RGB_RED</NAME>
#define RGB_RED     RGB_TO_UINT(0xff, 0x00, 0x00)
</MACRO>
<MACRO>
<NAME>RGB_GREEN</NAME>
#define RGB_GREEN   RGB_TO_UINT(0x00, 0xff, 0x00)
</MACRO>
<MACRO>
<NAME>RGB_BLUE</NAME>
#define RGB_BLUE    RGB_TO_UINT(0x00, 0x00, 0xff)
</MACRO>
<MACRO>
<NAME>RGB_YELLOW</NAME>
#define RGB_YELLOW  RGB_TO_UINT(0xff, 0xff, 0x00)
</MACRO>
<MACRO>
<NAME>RGB_VIOLET</NAME>
#define RGB_VIOLET  RGB_TO_UINT(0xff, 0x00, 0xff)
</MACRO>
<MACRO>
<NAME>RGB_CYAN</NAME>
#define RGB_CYAN    RGB_TO_UINT(0x00, 0xff, 0xff)
</MACRO>
<MACRO>
<NAME>RGB_GREY</NAME>
#define RGB_GREY(x) RGB_TO_UINT(x,x,x)
</MACRO>
<MACRO>
<NAME>RGBA_TO_UINT</NAME>
#define RGBA_TO_UINT(r,g,b,a)	((((guint)(r))<<24)|(((guint)(g))<<16)|(((guint)(b))<<8)|(guint)(a))
</MACRO>
<MACRO>
<NAME>RGBA_WHITE</NAME>
#define RGBA_WHITE  RGB_TO_RGBA(RGB_WHITE, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_BLACK</NAME>
#define RGBA_BLACK  RGB_TO_RGBA(RGB_BLACK, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_RED</NAME>
#define RGBA_RED    RGB_TO_RGBA(RGB_RED, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_GREEN</NAME>
#define RGBA_GREEN  RGB_TO_RGBA(RGB_GREEN, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_BLUE</NAME>
#define RGBA_BLUE   RGB_TO_RGBA(RGB_BLUE, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_YELLOW</NAME>
#define RGBA_YELLOW RGB_TO_RGBA(RGB_YELLOW, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_VIOLET</NAME>
#define RGBA_VIOLET RGB_TO_RGBA(RGB_VIOLET, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_CYAN</NAME>
#define RGBA_CYAN   RGB_TO_RGBA(RGB_CYAN, 0xff)
</MACRO>
<MACRO>
<NAME>RGBA_GREY</NAME>
#define RGBA_GREY(x) RGB_TO_RGBA(RGB_GREY(x), 0xff)
</MACRO>
<MACRO>
<NAME>UINT_RGBA_R</NAME>
#define UINT_RGBA_R(x) (((guint)(x))>>24)
</MACRO>
<MACRO>
<NAME>UINT_RGBA_G</NAME>
#define UINT_RGBA_G(x) ((((guint)(x))>>16)&0xff)
</MACRO>
<MACRO>
<NAME>UINT_RGBA_B</NAME>
#define UINT_RGBA_B(x) ((((guint)(x))>>8)&0xff)
</MACRO>
<MACRO>
<NAME>UINT_RGBA_A</NAME>
#define UINT_RGBA_A(x) (((guint)(x))&0xff)
</MACRO>
<MACRO>
<NAME>UINT_RGBA_CHANGE_R</NAME>
#define UINT_RGBA_CHANGE_R(x, r) (((x)&(~(0xff<<24)))|(((r)&0xff)<<24))
</MACRO>
<MACRO>
<NAME>UINT_RGBA_CHANGE_G</NAME>
#define UINT_RGBA_CHANGE_G(x, g) (((x)&(~(0xff<<16)))|(((g)&0xff)<<16))
</MACRO>
<MACRO>
<NAME>UINT_RGBA_CHANGE_B</NAME>
#define UINT_RGBA_CHANGE_B(x, b) (((x)&(~(0xff<<8)))|(((b)&0xff)<<8))
</MACRO>
<MACRO>
<NAME>UINT_RGBA_CHANGE_A</NAME>
#define UINT_RGBA_CHANGE_A(x, a) (((x)&(~0xff))|((a)&0xff))
</MACRO>
<MACRO>
<NAME>UINT_TO_RGB</NAME>
#define UINT_TO_RGB(u,r,g,b) \
{ (*(r)) = ((u)>>16)&0xff; (*(g)) = ((u)>>8)&0xff; (*(b)) = (u)&0xff; }
</MACRO>
<MACRO>
<NAME>UINT_TO_RGBA</NAME>
#define UINT_TO_RGBA(u,r,g,b,a) \
{ UINT_TO_RGB(((u)>>8),r,g,b); (*(a)) = (u)&0xff; }
</MACRO>
<MACRO>
<NAME>MONO_INTERPOLATE</NAME>
#define MONO_INTERPOLATE(v1, v2, t) ((gint)go_rint((v2)*(t)+(v1)*(1-(t))))
</MACRO>
<MACRO>
<NAME>UINT_INTERPOLATE</NAME>
#define UINT_INTERPOLATE(c1, c2, t) \
  RGBA_TO_UINT( MONO_INTERPOLATE(UINT_RGBA_R(c1), UINT_RGBA_R(c2), t), \
		MONO_INTERPOLATE(UINT_RGBA_G(c1), UINT_RGBA_G(c2), t), \
		MONO_INTERPOLATE(UINT_RGBA_B(c1), UINT_RGBA_B(c2), t), \
		MONO_INTERPOLATE(UINT_RGBA_A(c1), UINT_RGBA_A(c2), t) )
</MACRO>
<MACRO>
<NAME>PIXEL_RGB</NAME>
#define PIXEL_RGB(p, r, g, b) \
{((guchar*)(p))[0]=(r); ((guchar*)(p))[1]=(g); ((guchar*)(p))[2]=(b);}
</MACRO>
<MACRO>
<NAME>PIXEL_RGBA</NAME>
#define PIXEL_RGBA(p, r, g, b, a) \
{ if ((a)>=0xff) { PIXEL_RGB(p,r,g,b) } \
  else if ((a)>0) { \
    guint pixel_tmp; \
    pixel_tmp = ((guchar*)(p))[0]; \
    ((guchar*)(p))[0] = pixel_tmp + ((((r)-pixel_tmp)*(a)+0x80) >> 8); \
    pixel_tmp = ((guchar*)(p))[1]; \
    ((guchar*)(p))[1] = pixel_tmp + ((((g)-pixel_tmp)*(a)+0x80) >> 8); \
    pixel_tmp = ((guchar*)(p))[2]; \
    ((guchar*)(p))[2] = pixel_tmp + ((((b)-pixel_tmp)*(a)+0x80) >> 8); }}
</MACRO>
<MACRO>
<NAME>PIXEL_RGB_UINT</NAME>
#define PIXEL_RGB_UINT(p, i) \
UINT_TO_RGB((i), ((guchar*)p), ((guchar*)p)+1, ((guchar*)p)+2)
</MACRO>
<MACRO>
<NAME>PIXEL_RGBA_UINT</NAME>
#define PIXEL_RGBA_UINT(p, i) \
  PIXEL_RGBA((p), ((i)>>24)&0xff, ((i)>>16)&0xff, ((i)>>8)&0xff, (i)&0xff)
</MACRO>
<MACRO>
<NAME>PIXEL_BLACK</NAME>
#define PIXEL_BLACK(p) PIXEL_RGB(p,0,0,0)
</MACRO>
<MACRO>
<NAME>PIXEL_WHITE</NAME>
#define PIXEL_WHITE(p) PIXEL_RGB(p,0xff,0xff,0xff)
</MACRO>
<MACRO>
<NAME>PIXEL_GREY</NAME>
#define PIXEL_GREY(p,g) PIXEL_RGB(p,g,g,g)
</MACRO>
<MACRO>
<NAME>PIXEL_GREYA</NAME>
#define PIXEL_GREYA(p,g,a) PIXEL_RGBA(p,g,g,g,a)
</MACRO>
<MACRO>
<NAME>DOUBLE_RGBA_R</NAME>
#define DOUBLE_RGBA_R(x) (double)UINT_RGBA_R(x)/255.0
</MACRO>
<MACRO>
<NAME>DOUBLE_RGBA_G</NAME>
#define DOUBLE_RGBA_G(x) (double)UINT_RGBA_G(x)/255.0
</MACRO>
<MACRO>
<NAME>DOUBLE_RGBA_B</NAME>
#define DOUBLE_RGBA_B(x) (double)UINT_RGBA_B(x)/255.0
</MACRO>
<MACRO>
<NAME>DOUBLE_RGBA_A</NAME>
#define DOUBLE_RGBA_A(x) (double)UINT_RGBA_A(x)/255.0
</MACRO>
<MACRO>
<NAME>GO_COLOR_TO_CAIRO</NAME>
#define GO_COLOR_TO_CAIRO(x) DOUBLE_RGBA_R(x),DOUBLE_RGBA_G(x),DOUBLE_RGBA_B(x),DOUBLE_RGBA_A(x)
</MACRO>
<FUNCTION>
<NAME>go_color_to_artpix</NAME>
<RETURNS>void </RETURNS>
ArtPixMaxDepth *res, GOColor rgba
</FUNCTION>
<FUNCTION>
<NAME>go_color_render_svp</NAME>
<RETURNS>void </RETURNS>
GOColor color, ArtSVP const *svp,int x0, int y0, int x1, int y1,art_u8 *buf, int rowstride
</FUNCTION>
<FUNCTION>
<NAME>go_color_from_str</NAME>
<RETURNS>gboolean  </RETURNS>
char const *str, GOColor *res
</FUNCTION>
<FUNCTION>
<NAME>go_color_as_str</NAME>
<RETURNS>gchar    *</RETURNS>
GOColor color
</FUNCTION>
<FUNCTION>
<NAME>go_color_to_pango</NAME>
<RETURNS>PangoAttribute *</RETURNS>
GOColor color, gboolean is_fore
</FUNCTION>
<FUNCTION>
<NAME>go_color_to_gdk</NAME>
<RETURNS>GdkColor *</RETURNS>
GOColor color, GdkColor *res
</FUNCTION>
<MACRO>
<NAME>GO_MARKER_TYPE</NAME>
#define GO_MARKER_TYPE	  	(go_marker_get_type ())
</MACRO>
<MACRO>
<NAME>GO_MARKER</NAME>
#define GO_MARKER(o)		(G_TYPE_CHECK_INSTANCE_CAST((o), GO_MARKER_TYPE, GOMarker))
</MACRO>
<MACRO>
<NAME>IS_GO_MARKER</NAME>
#define IS_GO_MARKER(o)		(G_TYPE_CHECK_INSTANCE_TYPE((o), GO_MARKER_TYPE))
</MACRO>
<ENUM>
<NAME>GOMarkerShape</NAME>
typedef enum {
	GO_MARKER_NONE,
	GO_MARKER_SQUARE,
	GO_MARKER_DIAMOND,
	GO_MARKER_TRIANGLE_DOWN,
	GO_MARKER_TRIANGLE_UP,
	GO_MARKER_TRIANGLE_RIGHT,
	GO_MARKER_TRIANGLE_LEFT,
	GO_MARKER_CIRCLE,
	GO_MARKER_X,
	GO_MARKER_CROSS,
	GO_MARKER_ASTERISK,
	GO_MARKER_BAR,
	GO_MARKER_HALF_BAR,
	GO_MARKER_BUTTERFLY,
	GO_MARKER_HOURGLASS,
	GO_MARKER_MAX
} GOMarkerShape;
</ENUM>
<FUNCTION>
<NAME>go_marker_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_marker_shape_from_str</NAME>
<RETURNS>GOMarkerShape    </RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>go_marker_shape_as_str</NAME>
<RETURNS>char const      *</RETURNS>
GOMarkerShape shape
</FUNCTION>
<FUNCTION>
<NAME>go_marker_get_shape</NAME>
<RETURNS>GOMarkerShape 	 </RETURNS>
GOMarker const *m
</FUNCTION>
<FUNCTION>
<NAME>go_marker_set_shape</NAME>
<RETURNS>void 		 </RETURNS>
GOMarker *m, GOMarkerShape shape
</FUNCTION>
<FUNCTION>
<NAME>go_marker_get_outline_color</NAME>
<RETURNS>GOColor 	 </RETURNS>
GOMarker const *m
</FUNCTION>
<FUNCTION>
<NAME>go_marker_set_outline_color</NAME>
<RETURNS>void		 </RETURNS>
GOMarker *m, GOColor color
</FUNCTION>
<FUNCTION>
<NAME>go_marker_get_fill_color</NAME>
<RETURNS>GOColor		 </RETURNS>
GOMarker const *m
</FUNCTION>
<FUNCTION>
<NAME>go_marker_set_fill_color</NAME>
<RETURNS>void		 </RETURNS>
GOMarker *m, GOColor color
</FUNCTION>
<FUNCTION>
<NAME>go_marker_get_size</NAME>
<RETURNS>int		 </RETURNS>
GOMarker const *m
</FUNCTION>
<FUNCTION>
<NAME>go_marker_set_size</NAME>
<RETURNS>void		 </RETURNS>
GOMarker *m, int size
</FUNCTION>
<FUNCTION>
<NAME>go_marker_get_outline_width</NAME>
<RETURNS>double		 </RETURNS>
GOMarker const *m
</FUNCTION>
<FUNCTION>
<NAME>go_marker_assign</NAME>
<RETURNS>void		 </RETURNS>
GOMarker *dst, GOMarker const *src
</FUNCTION>
<FUNCTION>
<NAME>go_marker_dup</NAME>
<RETURNS>GOMarker *</RETURNS>
GOMarker const *src
</FUNCTION>
<FUNCTION>
<NAME>go_marker_new</NAME>
<RETURNS>GOMarker *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_marker_render</NAME>
<RETURNS>void 		 </RETURNS>
GOMarker const *marker, cairo_t *cr,double x, double y, double scale
</FUNCTION>
<FUNCTION>
<NAME>go_marker_create_cairo_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GOMarker const *marker, cairo_t *cr, double scale,double *width, double *height
</FUNCTION>
<ENUM>
<NAME>GOLineDashType</NAME>
typedef enum {
	GO_LINE_NONE,
	GO_LINE_SOLID,
	GO_LINE_S_DOT,
	GO_LINE_S_DASH_DOT,
	GO_LINE_S_DASH_DOT_DOT,
	GO_LINE_DASH_DOT_DOT_DOT,
	GO_LINE_DOT,
	GO_LINE_S_DASH,
	GO_LINE_DASH,
	GO_LINE_LONG_DASH,
	GO_LINE_DASH_DOT,
	GO_LINE_DASH_DOT_DOT,
	GO_LINE_MAX
} GOLineDashType;
</ENUM>
<ENUM>
<NAME>GOLineInterpolation</NAME>
typedef enum {
	GO_LINE_INTERPOLATION_LINEAR,
	GO_LINE_INTERPOLATION_SPLINE,
	GO_LINE_INTERPOLATION_STEP_START,
	GO_LINE_INTERPOLATION_STEP_END,
	GO_LINE_INTERPOLATION_STEP_CENTER_X,
	GO_LINE_INTERPOLATION_STEP_CENTER_Y,
	GO_LINE_INTERPOLATION_MAX
} GOLineInterpolation;
</ENUM>
<STRUCT>
<NAME>GOLineDashSequence</NAME>
typedef struct {
	double		 offset;
	unsigned int	 n_dash;
	double		*dash;
} GOLineDashSequence;
</STRUCT>
<FUNCTION>
<NAME>go_line_dash_from_str</NAME>
<RETURNS>GOLineDashType		 </RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>go_line_dash_as_str</NAME>
<RETURNS>char const 		*</RETURNS>
GOLineDashType type
</FUNCTION>
<FUNCTION>
<NAME>go_line_dash_as_label</NAME>
<RETURNS>char const 		*</RETURNS>
GOLineDashType type
</FUNCTION>
<FUNCTION>
<NAME>go_line_dash_get_length</NAME>
<RETURNS>double			 </RETURNS>
GOLineDashType type
</FUNCTION>
<FUNCTION>
<NAME>go_line_dash_get_sequence</NAME>
<RETURNS>GOLineDashSequence	*</RETURNS>
GOLineDashType type, double scale
</FUNCTION>
<FUNCTION>
<NAME>go_line_dash_sequence_free</NAME>
<RETURNS>void 		  	 </RETURNS>
GOLineDashSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>go_line_interpolation_from_str</NAME>
<RETURNS>GOLineInterpolation	 </RETURNS>
char const *name
</FUNCTION>
<FUNCTION>
<NAME>go_line_interpolation_as_str</NAME>
<RETURNS>char const 		*</RETURNS>
GOLineInterpolation type
</FUNCTION>
<TYPEDEF>
<NAME>GOColor</NAME>
typedef guint32				GOColor;
</TYPEDEF>
<STRUCT>
<NAME>GOFont</NAME>
</STRUCT>
<STRUCT>
<NAME>GOFontMetrics</NAME>
</STRUCT>
<STRUCT>
<NAME>GOPattern</NAME>
</STRUCT>
<STRUCT>
<NAME>GOMarker</NAME>
</STRUCT>
<STRUCT>
<NAME>GOFormat</NAME>
</STRUCT>
<STRUCT>
<NAME>GODateConventions</NAME>
</STRUCT>
<STRUCT>
<NAME>GOImage</NAME>
</STRUCT>
<STRUCT>
<NAME>GOMemChunk</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GOTranslateFunc</NAME>
<RETURNS>const char *</RETURNS>
char const *path, gpointer func_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GOMapFunc</NAME>
<RETURNS>gpointer </RETURNS>
gpointer value
</USER_FUNCTION>
<FUNCTION>
<NAME>go_ptr_array_insert</NAME>
<RETURNS>void	 </RETURNS>
GPtrArray *array, gpointer value, int index
</FUNCTION>
<FUNCTION>
<NAME>go_hash_keys</NAME>
<RETURNS>GSList	*</RETURNS>
GHashTable *hash
</FUNCTION>
<FUNCTION>
<NAME>go_hash_values</NAME>
<RETURNS>GSList	*</RETURNS>
GHashTable *hash
</FUNCTION>
<FUNCTION>
<NAME>go_slist_map</NAME>
<RETURNS>GSList	*</RETURNS>
GSList const *list, GOMapFunc map_func
</FUNCTION>
<FUNCTION>
<NAME>go_slist_create</NAME>
<RETURNS>GSList	*</RETURNS>
gpointer item1, ...
</FUNCTION>
<FUNCTION>
<NAME>go_slist_free_custom</NAME>
<RETURNS>void	 </RETURNS>
GSList *list, GFreeFunc free_func
</FUNCTION>
<MACRO>
<NAME>go_string_slist_copy</NAME>
#define	 go_string_slist_copy(list) go_slist_map (list, (GOMapFunc) g_strdup)
</MACRO>
<FUNCTION>
<NAME>go_strsplit_to_slist</NAME>
<RETURNS>GSList	*</RETURNS>
char const *str, gchar delimiter
</FUNCTION>
<MACRO>
<NAME>GO_SLIST_FOREACH</NAME>
#define GO_SLIST_FOREACH(list,valtype,val,stmnt) \
G_STMT_START { \
	GSList const *go_l; \
	for (go_l = (list); go_l != NULL; go_l = go_l->next) { \
		valtype *val = go_l->data; \
		stmnt \
		; \
	} \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>GO_SLIST_PREPEND</NAME>
#define GO_SLIST_PREPEND(list,item) \
	(list = g_slist_prepend (list, item))
</MACRO>
<MACRO>
<NAME>GO_SLIST_APPEND</NAME>
#define GO_SLIST_APPEND(list,item) \
	(list = g_slist_append (list, item))
</MACRO>
<MACRO>
<NAME>GO_SLIST_REMOVE</NAME>
#define GO_SLIST_REMOVE(list,item) \
	(list = g_slist_remove (list, item))
</MACRO>
<MACRO>
<NAME>GO_SLIST_CONCAT</NAME>
#define GO_SLIST_CONCAT(list_a,list_b) \
	(list_a = g_slist_concat (list_a, list_b))
</MACRO>
<MACRO>
<NAME>GO_SLIST_REVERSE</NAME>
#define GO_SLIST_REVERSE(list) \
	(list = g_slist_reverse (list))
</MACRO>
<MACRO>
<NAME>GO_SLIST_SORT</NAME>
#define GO_SLIST_SORT(list,cmp_func) \
	(list = g_slist_sort (list, cmp_func))
</MACRO>
<FUNCTION>
<NAME>go_list_index_custom</NAME>
<RETURNS>gint </RETURNS>
GList *list, gpointer data, GCompareFunc cmp_func
</FUNCTION>
<FUNCTION>
<NAME>go_list_free_custom</NAME>
<RETURNS>void </RETURNS>
GList *list, GFreeFunc free_func
</FUNCTION>
<MACRO>
<NAME>GO_LIST_FOREACH</NAME>
#define GO_LIST_FOREACH(list,valtype,val,stmnt) \
G_STMT_START { \
	GList *go_l; \
	for (go_l = (list); go_l != NULL; go_l = go_l->next) { \
		valtype *val = go_l->data; \
		stmnt \
		; \
	} \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>GO_LIST_PREPEND</NAME>
#define GO_LIST_PREPEND(list,item) \
	(list = g_list_prepend (list, item))
</MACRO>
<MACRO>
<NAME>GO_LIST_APPEND</NAME>
#define GO_LIST_APPEND(list,item) \
	(list = g_list_append (list, item))
</MACRO>
<MACRO>
<NAME>GO_LIST_REMOVE</NAME>
#define GO_LIST_REMOVE(list,item) \
	(list = g_list_remove (list, item))
</MACRO>
<MACRO>
<NAME>GO_LIST_CONCAT</NAME>
#define GO_LIST_CONCAT(list_a,list_b) \
	(list_a = g_list_concat (list_a, list_b))
</MACRO>
<MACRO>
<NAME>GO_LIST_REVERSE</NAME>
#define GO_LIST_REVERSE(list) \
	(list = g_list_reverse (list))
</MACRO>
<MACRO>
<NAME>GO_LIST_SORT</NAME>
#define GO_LIST_SORT(list,cmp_func) \
	(list = g_list_sort (list, cmp_func))
</MACRO>
<FUNCTION>
<NAME>go_str_compare</NAME>
<RETURNS>int	    </RETURNS>
void const *x, void const *y
</FUNCTION>
<FUNCTION>
<NAME>go_ascii_strcase_hash</NAME>
<RETURNS>guint	    </RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
<NAME>go_ascii_strcase_equal</NAME>
<RETURNS>gint	    </RETURNS>
gconstpointer v, gconstpointer v2
</FUNCTION>
<FUNCTION>
<NAME>go_utf8_collate_casefold</NAME>
<RETURNS>gint	    </RETURNS>
char const *a, char const *b
</FUNCTION>
<FUNCTION>
<NAME>go_utf8_strcapital</NAME>
<RETURNS>char	   *</RETURNS>
char const *p, gssize len
</FUNCTION>
<FUNCTION>
<NAME>go_strescape</NAME>
<RETURNS>void	    </RETURNS>
GString *target, char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_strunescape</NAME>
<RETURNS>char const *</RETURNS>
GString *target, char const *str
</FUNCTION>
<FUNCTION>
<NAME>go_string_append_gstring</NAME>
<RETURNS>void	    </RETURNS>
GString *target, const GString *src
</FUNCTION>
<FUNCTION>
<NAME>go_string_append_c_n</NAME>
<RETURNS>void        </RETURNS>
GString *target, char c, gsize n
</FUNCTION>
<FUNCTION>
<NAME>go_guess_encoding</NAME>
<RETURNS>char const *</RETURNS>
char const *raw, size_t len,char const *user_guess,char **utf8_str
</FUNCTION>
<FUNCTION>
<NAME>go_get_real_name</NAME>
<RETURNS>char const *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>go_destroy_password</NAME>
<RETURNS>void	    </RETURNS>
char *passwd
</FUNCTION>
<FUNCTION>
<NAME>go_mem_chunk_new</NAME>
<RETURNS>GOMemChunk  *</RETURNS>
char const *name, size_t user_atom_size, size_t chunk_size
</FUNCTION>
<FUNCTION>
<NAME>go_mem_chunk_destroy</NAME>
<RETURNS>void	     </RETURNS>
GOMemChunk *chunk, gboolean expect_leaks
</FUNCTION>
<FUNCTION>
<NAME>go_mem_chunk_alloc</NAME>
<RETURNS>gpointer     </RETURNS>
GOMemChunk *chunk
</FUNCTION>
<FUNCTION>
<NAME>go_mem_chunk_alloc0</NAME>
<RETURNS>gpointer     </RETURNS>
GOMemChunk *chunk
</FUNCTION>
<FUNCTION>
<NAME>go_mem_chunk_free</NAME>
<RETURNS>void         </RETURNS>
GOMemChunk *chunk, gpointer mem
</FUNCTION>
<FUNCTION>
<NAME>go_mem_chunk_foreach_leak</NAME>
<RETURNS>void         </RETURNS>
GOMemChunk *chunk, GFunc cb, gpointer user
</FUNCTION>
<FUNCTION>
<NAME>go_object_toggle</NAME>
<RETURNS>void	</RETURNS>
gpointer object,const gchar *property_name
</FUNCTION>
<FUNCTION>
<NAME>go_object_set_property</NAME>
<RETURNS>gboolean </RETURNS>
GObject *obj, const char *property_name,const char *user_prop_name, const char *value,GError **err,const char *error_template
</FUNCTION>
<FUNCTION>
<NAME>go_object_properties_collect</NAME>
<RETURNS>GSList *</RETURNS>
GObject *obj
</FUNCTION>
<FUNCTION>
<NAME>go_object_properties_apply</NAME>
<RETURNS>void    </RETURNS>
GObject *obj,GSList *props,gboolean changed_only
</FUNCTION>
<FUNCTION>
<NAME>go_object_properties_free</NAME>
<RETURNS>void    </RETURNS>
GSList *props
</FUNCTION>
<USER_FUNCTION>
<NAME>GOParseKeyValueFunc</NAME>
<RETURNS>gboolean </RETURNS>
const char *name,
		  const char *value,
		  GError **err,
		  gpointer user
</USER_FUNCTION>
<FUNCTION>
<NAME>go_parse_key_value</NAME>
<RETURNS>gboolean </RETURNS>
const char *options,GError **err,GOParseKeyValueFunc	func,gpointer user
</FUNCTION>
