/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */

#include <Python.h>



#line 52 "cplplotcanvas.override"
#include <Python.h>        
       
#include "pygobject.h"
#include "plplot.h"
#include "plplotcanvas.h"

#define PY_ARRAY_UNIQUE_SYMBOL plplotcanvasapi
#include "Numeric/arrayobject.h"
#line 17 "plplotcanvas.c"


/* ---------- types from other modules ---------- */
static PyTypeObject *_PyGnomeCanvas_Type;
#define PyGnomeCanvas_Type (*_PyGnomeCanvas_Type)


/* ---------- forward type declarations ---------- */
PyTypeObject PyPlplotCanvas_Type;

#line 28 "plplotcanvas.c"



/* ----------- PlplotCanvas ----------- */

#line 133 "cplplotcanvas.override"
static int
_wrap_plplot_canvas_new(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    GType obj_type = pyg_type_from_object((PyObject *) self);

    self->obj = g_object_new(obj_type, "aa", TRUE, NULL);
    if (!self->obj) {
        PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object");
        return -1;
    }

    pygobject_register_wrapper((PyObject *)self);
    return 0;
}
#line 49 "plplotcanvas.c"


static PyObject *
_wrap_plplot_canvas_devinit(PyGObject *self)
{
    plplot_canvas_devinit(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_dispose(PyGObject *self)
{
    plplot_canvas_dispose(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_get_stream_number(PyGObject *self)
{
    int ret;

    ret = plplot_canvas_get_stream_number(PLPLOT_CANVAS(self->obj));
    return PyInt_FromLong(ret);
}

static PyObject *
_wrap_plplot_canvas_set_size(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "width", "height", NULL };
    int width, height;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.set_size", kwlist, &width, &height))
        return NULL;
    plplot_canvas_set_size(PLPLOT_CANVAS(self->obj), width, height);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_set_zoom(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "magnification", NULL };
    double magnification;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:PlplotCanvas.set_zoom", kwlist, &magnification))
        return NULL;
    plplot_canvas_set_zoom(PLPLOT_CANVAS(self->obj), magnification);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_use_text(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "use_text", NULL };
    int use_text;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.use_text", kwlist, &use_text))
        return NULL;
    plplot_canvas_use_text(PLPLOT_CANVAS(self->obj), use_text);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_use_pixmap(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "use_pixmap", NULL };
    int use_pixmap;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.use_pixmap", kwlist, &use_pixmap))
        return NULL;
    plplot_canvas_use_pixmap(PLPLOT_CANVAS(self->obj), use_pixmap);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_use_persistence(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "use_persistence", NULL };
    int use_persistence;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.use_persistence", kwlist, &use_persistence))
        return NULL;
    plplot_canvas_use_persistence(PLPLOT_CANVAS(self->obj), use_persistence);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_setcontlabelformat(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "lexp", "sigdig", NULL };
    int lexp, sigdig;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.setcontlabelformat", kwlist, &lexp, &sigdig))
        return NULL;
    plplot_canvas_setcontlabelformat(PLPLOT_CANVAS(self->obj), lexp, sigdig);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_setcontlabelparam(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "offset", "size", "spacing", "active", NULL };
    int active;
    double offset, size, spacing;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddi:PlplotCanvas.setcontlabelparam", kwlist, &offset, &size, &spacing, &active))
        return NULL;
    plplot_canvas_setcontlabelparam(PLPLOT_CANVAS(self->obj), offset, size, spacing, active);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_adv(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "page", NULL };
    int page;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.adv", kwlist, &page))
        return NULL;
    plplot_canvas_adv(PLPLOT_CANVAS(self->obj), page);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_bop(PyGObject *self)
{
    plplot_canvas_bop(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_clear(PyGObject *self)
{
    plplot_canvas_clear(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_col0(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "icol0", NULL };
    int icol0;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.col0", kwlist, &icol0))
        return NULL;
    plplot_canvas_col0(PLPLOT_CANVAS(self->obj), icol0);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_col1(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "col1", NULL };
    double col1;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:PlplotCanvas.col1", kwlist, &col1))
        return NULL;
    plplot_canvas_col1(PLPLOT_CANVAS(self->obj), col1);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_eop(PyGObject *self)
{
    plplot_canvas_eop(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_font(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "ifont", NULL };
    int ifont;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.font", kwlist, &ifont))
        return NULL;
    plplot_canvas_font(PLPLOT_CANVAS(self->obj), ifont);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_fontld(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "fnt", NULL };
    int fnt;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.fontld", kwlist, &fnt))
        return NULL;
    plplot_canvas_fontld(PLPLOT_CANVAS(self->obj), fnt);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_gfnam(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "fnam", NULL };
    char *fnam;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:PlplotCanvas.gfnam", kwlist, &fnam))
        return NULL;
    plplot_canvas_gfnam(PLPLOT_CANVAS(self->obj), fnam);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_hls(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "h", "l", "s", NULL };
    double h, l, s;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddd:PlplotCanvas.hls", kwlist, &h, &l, &s))
        return NULL;
    plplot_canvas_hls(PLPLOT_CANVAS(self->obj), h, l, s);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_join(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "x1", "y1", "x2", "y2", NULL };
    double x1, y1, x2, y2;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.join", kwlist, &x1, &y1, &x2, &y2))
        return NULL;
    plplot_canvas_join(PLPLOT_CANVAS(self->obj), x1, y1, x2, y2);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_lightsource(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "x", "y", "z", NULL };
    double x, y, z;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddd:PlplotCanvas.lightsource", kwlist, &x, &y, &z))
        return NULL;
    plplot_canvas_lightsource(PLPLOT_CANVAS(self->obj), x, y, z);
    Py_INCREF(Py_None);
    return Py_None;
}

#line 149 "cplplotcanvas.override"
static PyObject* _wrap_plplot_canvas_line(PyGObject *self,
					  PyObject *args)
{
    PyObject *x_,*y_;
    PyArrayObject *x, *y;

    if(!PyArg_UnpackTuple(args,"ref",2,2,&x_,&y_))
	return NULL;

    if(!PyArray_Check(x_)) return NULL;
    if( (x = (PyArrayObject *)
	 PyArray_ContiguousFromObject(x_, PyArray_DOUBLE, 1, 1)) == NULL)
	return NULL;

    if(!PyArray_Check(y_)) return NULL;
    if( (y = (PyArrayObject *)
	 PyArray_ContiguousFromObject(y_, PyArray_DOUBLE, 1, 1)) == NULL)
	return NULL;

    plplot_canvas_line(PLPLOT_CANVAS(self->obj),
		       x->dimensions[0],(double*)x->data,(double*)y->data);

    return Py_BuildValue("");
}
#line 335 "plplotcanvas.c"


static PyObject *
_wrap_plplot_canvas_lsty(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "lin", NULL };
    int lin;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.lsty", kwlist, &lin))
        return NULL;
    plplot_canvas_lsty(PLPLOT_CANVAS(self->obj), lin);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_mtex(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "side", "disp", "pos", "just", "text", NULL };
    char *side, *text;
    double disp, pos, just;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sddds:PlplotCanvas.mtex", kwlist, &side, &disp, &pos, &just, &text))
        return NULL;
    plplot_canvas_mtex(PLPLOT_CANVAS(self->obj), side, disp, pos, just, text);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_prec(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "setp", "prec", NULL };
    int setp, prec;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.prec", kwlist, &setp, &prec))
        return NULL;
    plplot_canvas_prec(PLPLOT_CANVAS(self->obj), setp, prec);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_psty(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "patt", NULL };
    int patt;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.psty", kwlist, &patt))
        return NULL;
    plplot_canvas_psty(PLPLOT_CANVAS(self->obj), patt);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_replot(PyGObject *self)
{
    plplot_canvas_replot(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_rgb(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "r", "g", "b", NULL };
    double r, g, b;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddd:PlplotCanvas.rgb", kwlist, &r, &g, &b))
        return NULL;
    plplot_canvas_rgb(PLPLOT_CANVAS(self->obj), r, g, b);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_rgb1(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "r", "g", "b", NULL };
    int r, g, b;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iii:PlplotCanvas.rgb1", kwlist, &r, &g, &b))
        return NULL;
    plplot_canvas_rgb1(PLPLOT_CANVAS(self->obj), r, g, b);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_schr(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "def_", "scale", NULL };
    double def, scale;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:PlplotCanvas.schr", kwlist, &def, &scale))
        return NULL;
    plplot_canvas_schr(PLPLOT_CANVAS(self->obj), def, scale);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_scmap0n(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "ncol0", NULL };
    int ncol0;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.scmap0n", kwlist, &ncol0))
        return NULL;
    plplot_canvas_scmap0n(PLPLOT_CANVAS(self->obj), ncol0);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_scmap1n(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "ncol1", NULL };
    int ncol1;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.scmap1n", kwlist, &ncol1))
        return NULL;
    plplot_canvas_scmap1n(PLPLOT_CANVAS(self->obj), ncol1);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_scol0(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "icol0", "r", "g", "b", NULL };
    int icol0, r, g, b;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iiii:PlplotCanvas.scol0", kwlist, &icol0, &r, &g, &b))
        return NULL;
    plplot_canvas_scol0(PLPLOT_CANVAS(self->obj), icol0, r, g, b);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_scolbg(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "r", "g", "b", NULL };
    int r, g, b;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iii:PlplotCanvas.scolbg", kwlist, &r, &g, &b))
        return NULL;
    plplot_canvas_scolbg(PLPLOT_CANVAS(self->obj), r, g, b);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_scolor(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "color", NULL };
    int color;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.scolor", kwlist, &color))
        return NULL;
    plplot_canvas_scolor(PLPLOT_CANVAS(self->obj), color);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_scompression(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "compression", NULL };
    int compression;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.scompression", kwlist, &compression))
        return NULL;
    plplot_canvas_scompression(PLPLOT_CANVAS(self->obj), compression);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sdidev(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "mar", "aspect", "jx", "jy", NULL };
    double mar, aspect, jx, jy;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.sdidev", kwlist, &mar, &aspect, &jx, &jy))
        return NULL;
    plplot_canvas_sdidev(PLPLOT_CANVAS(self->obj), mar, aspect, jx, jy);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sdimap(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "dimxmin", "dimxmax", "dimymin", "dimymax", "dimxpmm", "dimypmm", NULL };
    int dimxmin, dimxmax, dimymin, dimymax;
    double dimxpmm, dimypmm;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iiiidd:PlplotCanvas.sdimap", kwlist, &dimxmin, &dimxmax, &dimymin, &dimymax, &dimxpmm, &dimypmm))
        return NULL;
    plplot_canvas_sdimap(PLPLOT_CANVAS(self->obj), dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sdiori(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "rot", NULL };
    double rot;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:PlplotCanvas.sdiori", kwlist, &rot))
        return NULL;
    plplot_canvas_sdiori(PLPLOT_CANVAS(self->obj), rot);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sdiplt(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xmin", "ymin", "xmax", "ymax", NULL };
    double xmin, ymin, xmax, ymax;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.sdiplt", kwlist, &xmin, &ymin, &xmax, &ymax))
        return NULL;
    plplot_canvas_sdiplt(PLPLOT_CANVAS(self->obj), xmin, ymin, xmax, ymax);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sdiplz(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xmin", "ymin", "xmax", "ymax", NULL };
    double xmin, ymin, xmax, ymax;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.sdiplz", kwlist, &xmin, &ymin, &xmax, &ymax))
        return NULL;
    plplot_canvas_sdiplz(PLPLOT_CANVAS(self->obj), xmin, ymin, xmax, ymax);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sesc(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "esc", NULL };
    char esc;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "c:PlplotCanvas.sesc", kwlist, &esc))
        return NULL;
    plplot_canvas_sesc(PLPLOT_CANVAS(self->obj), esc);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sfnam(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "fnam", NULL };
    char *fnam;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:PlplotCanvas.sfnam", kwlist, &fnam))
        return NULL;
    plplot_canvas_sfnam(PLPLOT_CANVAS(self->obj), fnam);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_smaj(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "def_", "scale", NULL };
    double def, scale;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:PlplotCanvas.smaj", kwlist, &def, &scale))
        return NULL;
    plplot_canvas_smaj(PLPLOT_CANVAS(self->obj), def, scale);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_smin(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "def_", "scale", NULL };
    double def, scale;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:PlplotCanvas.smin", kwlist, &def, &scale))
        return NULL;
    plplot_canvas_smin(PLPLOT_CANVAS(self->obj), def, scale);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_spage(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xp", "yp", "xleng", "yleng", "xoff", "yoff", NULL };
    int xleng, yleng, xoff, yoff;
    double xp, yp;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddiiii:PlplotCanvas.spage", kwlist, &xp, &yp, &xleng, &yleng, &xoff, &yoff))
        return NULL;
    plplot_canvas_spage(PLPLOT_CANVAS(self->obj), xp, yp, xleng, yleng, xoff, yoff);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_ssub(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "nx", "ny", NULL };
    int nx, ny;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.ssub", kwlist, &nx, &ny))
        return NULL;
    plplot_canvas_ssub(PLPLOT_CANVAS(self->obj), nx, ny);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_ssym(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "def_", "scale", NULL };
    double def, scale;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dd:PlplotCanvas.ssym", kwlist, &def, &scale))
        return NULL;
    plplot_canvas_ssym(PLPLOT_CANVAS(self->obj), def, scale);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_svpa(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xmin", "xmax", "ymin", "ymax", NULL };
    double xmin, xmax, ymin, ymax;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.svpa", kwlist, &xmin, &xmax, &ymin, &ymax))
        return NULL;
    plplot_canvas_svpa(PLPLOT_CANVAS(self->obj), xmin, xmax, ymin, ymax);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sxax(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "digmax", "digits", NULL };
    int digmax, digits;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.sxax", kwlist, &digmax, &digits))
        return NULL;
    plplot_canvas_sxax(PLPLOT_CANVAS(self->obj), digmax, digits);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_sxwin(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "window_id", NULL };
    int window_id;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.sxwin", kwlist, &window_id))
        return NULL;
    plplot_canvas_sxwin(PLPLOT_CANVAS(self->obj), window_id);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_syax(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "digmax", "digits", NULL };
    int digmax, digits;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.syax", kwlist, &digmax, &digits))
        return NULL;
    plplot_canvas_syax(PLPLOT_CANVAS(self->obj), digmax, digits);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_szax(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "digmax", "digits", NULL };
    int digmax, digits;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:PlplotCanvas.szax", kwlist, &digmax, &digits))
        return NULL;
    plplot_canvas_szax(PLPLOT_CANVAS(self->obj), digmax, digits);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_text(PyGObject *self)
{
    plplot_canvas_text(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_vasp(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "aspect", NULL };
    double aspect;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:PlplotCanvas.vasp", kwlist, &aspect))
        return NULL;
    plplot_canvas_vasp(PLPLOT_CANVAS(self->obj), aspect);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_vpas(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xmin", "xmax", "ymin", "ymax", "aspect", NULL };
    double xmin, xmax, ymin, ymax, aspect;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddddd:PlplotCanvas.vpas", kwlist, &xmin, &xmax, &ymin, &ymax, &aspect))
        return NULL;
    plplot_canvas_vpas(PLPLOT_CANVAS(self->obj), xmin, xmax, ymin, ymax, aspect);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_vpor(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xmin", "xmax", "ymin", "ymax", NULL };
    double xmin, xmax, ymin, ymax;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.vpor", kwlist, &xmin, &xmax, &ymin, &ymax))
        return NULL;
    plplot_canvas_vpor(PLPLOT_CANVAS(self->obj), xmin, xmax, ymin, ymax);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_vsta(PyGObject *self)
{
    plplot_canvas_vsta(PLPLOT_CANVAS(self->obj));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_w3d(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "basex", "basey", "height", "xmin0", "xmax0", "ymin0", "ymax0", "zmin0", "zmax0", "alt", "az", NULL };
    double basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0, alt, az;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddddddddddd:PlplotCanvas.w3d", kwlist, &basex, &basey, &height, &xmin0, &xmax0, &ymin0, &ymax0, &zmin0, &zmax0, &alt, &az))
        return NULL;
    plplot_canvas_w3d(PLPLOT_CANVAS(self->obj), basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0, alt, az);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_wid(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "width", NULL };
    int width;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:PlplotCanvas.wid", kwlist, &width))
        return NULL;
    plplot_canvas_wid(PLPLOT_CANVAS(self->obj), width);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
_wrap_plplot_canvas_wind(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "xmin", "xmax", "ymin", "ymax", NULL };
    double xmin, xmax, ymin, ymax;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "dddd:PlplotCanvas.wind", kwlist, &xmin, &xmax, &ymin, &ymax))
        return NULL;
    plplot_canvas_wind(PLPLOT_CANVAS(self->obj), xmin, xmax, ymin, ymax);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyMethodDef _PyPlplotCanvas_methods[] = {
    { "devinit", (PyCFunction)_wrap_plplot_canvas_devinit, METH_NOARGS },
    { "dispose", (PyCFunction)_wrap_plplot_canvas_dispose, METH_NOARGS },
    { "get_stream_number", (PyCFunction)_wrap_plplot_canvas_get_stream_number, METH_NOARGS },
    { "set_size", (PyCFunction)_wrap_plplot_canvas_set_size, METH_VARARGS|METH_KEYWORDS },
    { "set_zoom", (PyCFunction)_wrap_plplot_canvas_set_zoom, METH_VARARGS|METH_KEYWORDS },
    { "use_text", (PyCFunction)_wrap_plplot_canvas_use_text, METH_VARARGS|METH_KEYWORDS },
    { "use_pixmap", (PyCFunction)_wrap_plplot_canvas_use_pixmap, METH_VARARGS|METH_KEYWORDS },
    { "use_persistence", (PyCFunction)_wrap_plplot_canvas_use_persistence, METH_VARARGS|METH_KEYWORDS },
    { "setcontlabelformat", (PyCFunction)_wrap_plplot_canvas_setcontlabelformat, METH_VARARGS|METH_KEYWORDS },
    { "setcontlabelparam", (PyCFunction)_wrap_plplot_canvas_setcontlabelparam, METH_VARARGS|METH_KEYWORDS },
    { "adv", (PyCFunction)_wrap_plplot_canvas_adv, METH_VARARGS|METH_KEYWORDS },
    { "bop", (PyCFunction)_wrap_plplot_canvas_bop, METH_NOARGS },
    { "clear", (PyCFunction)_wrap_plplot_canvas_clear, METH_NOARGS },
    { "col0", (PyCFunction)_wrap_plplot_canvas_col0, METH_VARARGS|METH_KEYWORDS },
    { "col1", (PyCFunction)_wrap_plplot_canvas_col1, METH_VARARGS|METH_KEYWORDS },
    { "eop", (PyCFunction)_wrap_plplot_canvas_eop, METH_NOARGS },
    { "font", (PyCFunction)_wrap_plplot_canvas_font, METH_VARARGS|METH_KEYWORDS },
    { "fontld", (PyCFunction)_wrap_plplot_canvas_fontld, METH_VARARGS|METH_KEYWORDS },
    { "gfnam", (PyCFunction)_wrap_plplot_canvas_gfnam, METH_VARARGS|METH_KEYWORDS },
    { "hls", (PyCFunction)_wrap_plplot_canvas_hls, METH_VARARGS|METH_KEYWORDS },
    { "join", (PyCFunction)_wrap_plplot_canvas_join, METH_VARARGS|METH_KEYWORDS },
    { "lightsource", (PyCFunction)_wrap_plplot_canvas_lightsource, METH_VARARGS|METH_KEYWORDS },
    { "line", (PyCFunction)_wrap_plplot_canvas_line, METH_VARARGS },
    { "lsty", (PyCFunction)_wrap_plplot_canvas_lsty, METH_VARARGS|METH_KEYWORDS },
    { "mtex", (PyCFunction)_wrap_plplot_canvas_mtex, METH_VARARGS|METH_KEYWORDS },
    { "prec", (PyCFunction)_wrap_plplot_canvas_prec, METH_VARARGS|METH_KEYWORDS },
    { "psty", (PyCFunction)_wrap_plplot_canvas_psty, METH_VARARGS|METH_KEYWORDS },
    { "replot", (PyCFunction)_wrap_plplot_canvas_replot, METH_NOARGS },
    { "rgb", (PyCFunction)_wrap_plplot_canvas_rgb, METH_VARARGS|METH_KEYWORDS },
    { "rgb1", (PyCFunction)_wrap_plplot_canvas_rgb1, METH_VARARGS|METH_KEYWORDS },
    { "schr", (PyCFunction)_wrap_plplot_canvas_schr, METH_VARARGS|METH_KEYWORDS },
    { "scmap0n", (PyCFunction)_wrap_plplot_canvas_scmap0n, METH_VARARGS|METH_KEYWORDS },
    { "scmap1n", (PyCFunction)_wrap_plplot_canvas_scmap1n, METH_VARARGS|METH_KEYWORDS },
    { "scol0", (PyCFunction)_wrap_plplot_canvas_scol0, METH_VARARGS|METH_KEYWORDS },
    { "scolbg", (PyCFunction)_wrap_plplot_canvas_scolbg, METH_VARARGS|METH_KEYWORDS },
    { "scolor", (PyCFunction)_wrap_plplot_canvas_scolor, METH_VARARGS|METH_KEYWORDS },
    { "scompression", (PyCFunction)_wrap_plplot_canvas_scompression, METH_VARARGS|METH_KEYWORDS },
    { "sdidev", (PyCFunction)_wrap_plplot_canvas_sdidev, METH_VARARGS|METH_KEYWORDS },
    { "sdimap", (PyCFunction)_wrap_plplot_canvas_sdimap, METH_VARARGS|METH_KEYWORDS },
    { "sdiori", (PyCFunction)_wrap_plplot_canvas_sdiori, METH_VARARGS|METH_KEYWORDS },
    { "sdiplt", (PyCFunction)_wrap_plplot_canvas_sdiplt, METH_VARARGS|METH_KEYWORDS },
    { "sdiplz", (PyCFunction)_wrap_plplot_canvas_sdiplz, METH_VARARGS|METH_KEYWORDS },
    { "sesc", (PyCFunction)_wrap_plplot_canvas_sesc, METH_VARARGS|METH_KEYWORDS },
    { "sfnam", (PyCFunction)_wrap_plplot_canvas_sfnam, METH_VARARGS|METH_KEYWORDS },
    { "smaj", (PyCFunction)_wrap_plplot_canvas_smaj, METH_VARARGS|METH_KEYWORDS },
    { "smin", (PyCFunction)_wrap_plplot_canvas_smin, METH_VARARGS|METH_KEYWORDS },
    { "spage", (PyCFunction)_wrap_plplot_canvas_spage, METH_VARARGS|METH_KEYWORDS },
    { "ssub", (PyCFunction)_wrap_plplot_canvas_ssub, METH_VARARGS|METH_KEYWORDS },
    { "ssym", (PyCFunction)_wrap_plplot_canvas_ssym, METH_VARARGS|METH_KEYWORDS },
    { "svpa", (PyCFunction)_wrap_plplot_canvas_svpa, METH_VARARGS|METH_KEYWORDS },
    { "sxax", (PyCFunction)_wrap_plplot_canvas_sxax, METH_VARARGS|METH_KEYWORDS },
    { "sxwin", (PyCFunction)_wrap_plplot_canvas_sxwin, METH_VARARGS|METH_KEYWORDS },
    { "syax", (PyCFunction)_wrap_plplot_canvas_syax, METH_VARARGS|METH_KEYWORDS },
    { "szax", (PyCFunction)_wrap_plplot_canvas_szax, METH_VARARGS|METH_KEYWORDS },
    { "text", (PyCFunction)_wrap_plplot_canvas_text, METH_NOARGS },
    { "vasp", (PyCFunction)_wrap_plplot_canvas_vasp, METH_VARARGS|METH_KEYWORDS },
    { "vpas", (PyCFunction)_wrap_plplot_canvas_vpas, METH_VARARGS|METH_KEYWORDS },
    { "vpor", (PyCFunction)_wrap_plplot_canvas_vpor, METH_VARARGS|METH_KEYWORDS },
    { "vsta", (PyCFunction)_wrap_plplot_canvas_vsta, METH_NOARGS },
    { "w3d", (PyCFunction)_wrap_plplot_canvas_w3d, METH_VARARGS|METH_KEYWORDS },
    { "wid", (PyCFunction)_wrap_plplot_canvas_wid, METH_VARARGS|METH_KEYWORDS },
    { "wind", (PyCFunction)_wrap_plplot_canvas_wind, METH_VARARGS|METH_KEYWORDS },
    { NULL, NULL, 0 }
};

PyTypeObject PyPlplotCanvas_Type = {
    PyObject_HEAD_INIT(NULL)
    0,					/* ob_size */
    "Canvas",			/* tp_name */
    sizeof(PyGObject),	        /* tp_basicsize */
    0,					/* tp_itemsize */
    /* methods */
    (destructor)0,	/* tp_dealloc */
    (printfunc)0,			/* tp_print */
    (getattrfunc)0,	/* tp_getattr */
    (setattrfunc)0,	/* tp_setattr */
    (cmpfunc)0,		/* tp_compare */
    (reprfunc)0,		/* tp_repr */
    (PyNumberMethods*)0,     /* tp_as_number */
    (PySequenceMethods*)0, /* tp_as_sequence */
    (PyMappingMethods*)0,   /* tp_as_mapping */
    (hashfunc)0,		/* tp_hash */
    (ternaryfunc)0,		/* tp_call */
    (reprfunc)0,		/* tp_str */
    (getattrofunc)0,	/* tp_getattro */
    (setattrofunc)0,	/* tp_setattro */
    (PyBufferProcs*)0,	/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
    NULL, 				/* Documentation string */
    (traverseproc)0,	/* tp_traverse */
    (inquiry)0,		/* tp_clear */
    (richcmpfunc)0,	/* tp_richcompare */
    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
    (getiterfunc)0,		/* tp_iter */
    (iternextfunc)0,	/* tp_iternext */
    _PyPlplotCanvas_methods,			/* tp_methods */
    0,					/* tp_members */
    0,		       	/* tp_getset */
    NULL,				/* tp_base */
    NULL,				/* tp_dict */
    (descrgetfunc)0,	/* tp_descr_get */
    (descrsetfunc)0,	/* tp_descr_set */
    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
    (initproc)_wrap_plplot_canvas_new,		/* tp_init */
    (allocfunc)0,           /* tp_alloc */
    (newfunc)0,               /* tp_new */
    (freefunc)0,             /* tp_free */
    (inquiry)0              /* tp_is_gc */
};



/* ----------- functions ----------- */

PyMethodDef cplplotcanvas_functions[] = {
    { NULL, NULL, 0 }
};

/* initialise stuff extension classes */
void
cplplotcanvas_register_classes(PyObject *d)
{
    PyObject *module;

    if ((module = PyImport_ImportModule("gnome.canvas")) != NULL) {
        PyObject *moddict = PyModule_GetDict(module);

        _PyGnomeCanvas_Type = (PyTypeObject *)PyDict_GetItemString(moddict, "Canvas");
        if (_PyGnomeCanvas_Type == NULL) {
            PyErr_SetString(PyExc_ImportError,
                "cannot import name Canvas from gnome.canvas");
            return;
        }
    } else {
        PyErr_SetString(PyExc_ImportError,
            "could not import gnome.canvas");
        return;
    }


#line 974 "plplotcanvas.c"
    pygobject_register_class(d, "PlplotCanvas", PLPLOT_TYPE_CANVAS, &PyPlplotCanvas_Type, Py_BuildValue("(O)", &PyGnomeCanvas_Type));
}