clone 338090 -1 reassign -1 python-gtk2-dev 2.8.0-1 retitle -1 pygtk-codegen-2.0 from 2.8's pygtk generates code incompatible with python 2.3 severity -1 important thanks
Hi, On Mon, Nov 07, 2005, Manish Singh wrote: > Due to a bug upstream (http://bugzilla.gnome.org/show_bug.cgi?id=320931) > a python/vte.c generated for pygtk 2.8 is distributed with the tarball. > Since the date is newer than the other source files, it's not > regenerated, and the resultant binary does not work Thanks for your report, I've already forwarded a couple of reports on this matter upstream, namely Debian bugs #334001 and #334668, and this is discussed at: <http://bugzilla.gnome.org/show_bug.cgi?id=313454> I noted that this is specific to Python 2.3, and rebuilding python-vte with Python 2.4 will make it import like a charm. If I understand you correctly, python/vte.c is generated automatically (it seems via pygtk-codegen-2.0) and the resulting code is not suitable for Python 2.3. This seems to imply that this script has to be carefully split out in a python 2.3 and a python 2.4 version, or get some flags added to run in 2.3 compatibility mode. Hence, I removed vte.c and ran in a clean sid chroot (with pygtk 2.6.3-2): bee% pygtk-codegen-2.0 -p pyvte -o vte.override --register /usr/share/pygtk/2.0/defs/gtk-types.defs --register /usr/share/pygtk/2.0/defs/gdk-types.defs --register /usr/share/pygtk/2.0/defs/pango-types.defs vte.defs vte.override > vte.c Could not write method VteTerminal.forkpty: No ArgType for 'char**' Could not write method VteTerminal.match_check: No ArgType for 'int*' ***INFO*** The coverage of global functions is 100.00% (3/3) ***INFO*** The coverage of methods is 97.26% (71/73) ***INFO*** There are no declared virtual proxies. ***INFO*** There are no declared virtual accessors. ***INFO*** There are no declared interface proxies. and the result is the attached vte.c file which has only minor modifications beside this one: @@ -1548,7 +1546,6 @@ } -#line 1552 "vte.c" +#line 1550 "vte.c" pygobject_register_class(d, "VteTerminal", VTE_TYPE_TERMINAL, &PyVteTerminal_Type, Py_BuildValue("(O)", &PyGtkWidget_Type)); - pyg_set_object_has_new_constructor(VTE_TYPE_TERMINAL); } ... which suggest the problem will be fixed. Do you have any suggestion on fixing the root problem (ie. pygtk-codegen-2.0)? Should all packages be examined against this problem? Cheers, -- Loïc Minier <[EMAIL PROTECTED]>
/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */ #include <Python.h> #line 4 "vte.override" #include <Python.h> #include <pygtk/pygtk.h> #include <pygobject.h> #include <gtk/gtk.h> #include "../src/vte.h" #line 14 "vte.c" /* ---------- types from other modules ---------- */ static PyTypeObject *_PyGdkPixbuf_Type; #define PyGdkPixbuf_Type (*_PyGdkPixbuf_Type) static PyTypeObject *_PyGtkMenuShell_Type; #define PyGtkMenuShell_Type (*_PyGtkMenuShell_Type) static PyTypeObject *_PyGtkWidget_Type; #define PyGtkWidget_Type (*_PyGtkWidget_Type) /* ---------- forward type declarations ---------- */ PyTypeObject PyVteTerminal_Type; /* ----------- VteTerminal ----------- */ static int _wrap_vte_terminal_new(PyGObject *self, PyObject *args, PyObject *kwargs) { GType obj_type = pyg_type_from_object((PyObject *) self); static char* kwlist[] = { NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":vte.Terminal.__init__", kwlist)) return -1; self->obj = g_object_newv(obj_type, 0, NULL); if (!self->obj) { PyErr_SetString(PyExc_RuntimeError, "could not create %(typename)s object"); return -1; } pygobject_register_wrapper((PyObject *)self); return 0; } #line 75 "vte.override" static PyObject * _wrap_vte_terminal_fork_command(PyGObject * self, PyObject * args, PyObject * kwargs) { gchar **argv = NULL, **envv = NULL; gchar *command = NULL, *directory = NULL; static char *kwlist[] = { "command", "argv", "envv", "directory", "loglastlog", "logutmp", "logwtmp", NULL }; PyObject *py_argv = NULL, *py_envv = NULL, *loglastlog = NULL, *logutmp = NULL, *logwtmp = NULL; int i, n_args, n_envs; pid_t pid; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|sOOsOOO:fork_command", kwlist, &command, &py_argv, &py_envv, &directory, &loglastlog, &logutmp, &logwtmp)) { return NULL; } if (py_argv != NULL && py_argv != Py_None) { if (!PySequence_Check(py_argv)) { PyErr_SetString(PyExc_TypeError, "argv must be a sequence"); return NULL; } n_args = PySequence_Length(py_argv); argv = g_new(gchar *, n_args + 1); for (i = 0; i < n_args; i++) { PyObject *item = PySequence_GetItem(py_argv, i); Py_DECREF(item); /* PySequence_GetItem INCREF's */ argv[i] = PyString_AsString(item); } argv[n_args] = NULL; } if (py_envv != NULL && py_envv != Py_None) { if (!PySequence_Check(py_envv)) { PyErr_SetString(PyExc_TypeError, "envv must be a sequence"); return NULL; } n_envs = PySequence_Length(py_envv); envv = g_new(gchar *, n_envs + 1); for (i = 0; i < n_envs; i++) { PyObject *item = PySequence_GetItem(py_envv, i); Py_DECREF(item); /* PySequence_GetItem INCREF's */ envv[i] = PyString_AsString(item); } envv[n_envs] = NULL; } pid = vte_terminal_fork_command(VTE_TERMINAL(self->obj), command, argv, envv, directory, (loglastlog != NULL) && PyObject_IsTrue(loglastlog), (logutmp != NULL) && PyObject_IsTrue(logutmp), (logwtmp != NULL) && PyObject_IsTrue(logwtmp)); if (envv) { g_free(envv); } if (argv) { g_free(argv); } return PyInt_FromLong(pid); } #line 129 "vte.c" #line 17 "vte.override" static PyObject * _wrap_vte_terminal_feed(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "data", "length", NULL }; char *data; int length; PyObject *length_obj = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:VteTerminal.feed", kwlist, &data, &length, &length_obj)) { return NULL; } if ((length_obj != NULL) && PyNumber_Check(length_obj)) { PyObject *intobj; intobj = PyNumber_Int(length_obj); if (intobj) { if (PyInt_AsLong(intobj) != -1) { length = PyInt_AsLong(intobj); } Py_DECREF(intobj); } } vte_terminal_feed(VTE_TERMINAL(self->obj), data, length); Py_INCREF(Py_None); return Py_None; } #line 160 "vte.c" #line 46 "vte.override" static PyObject * _wrap_vte_terminal_feed_child(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "data", "length", NULL }; char *data; int length; PyObject *length_obj = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:VteTerminal.feed_child", kwlist, &data, &length, &length_obj)) { return NULL; } if ((length_obj != NULL) && PyNumber_Check(length_obj)) { PyObject *intobj; intobj = PyNumber_Int(length_obj); if (intobj) { if (PyInt_AsLong(intobj) != -1) { length = PyInt_AsLong(intobj); } Py_DECREF(intobj); } } vte_terminal_feed_child(VTE_TERMINAL(self->obj), data, length); Py_INCREF(Py_None); return Py_None; } #line 191 "vte.c" static PyObject * _wrap_vte_terminal_copy_clipboard(PyGObject *self) { vte_terminal_copy_clipboard(VTE_TERMINAL(self->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_paste_clipboard(PyGObject *self) { vte_terminal_paste_clipboard(VTE_TERMINAL(self->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_copy_primary(PyGObject *self) { vte_terminal_copy_primary(VTE_TERMINAL(self->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_paste_primary(PyGObject *self) { vte_terminal_paste_primary(VTE_TERMINAL(self->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_size(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "columns", "rows", NULL }; glong columns, rows; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ll:VteTerminal.set_size", kwlist, &columns, &rows)) return NULL; vte_terminal_set_size(VTE_TERMINAL(self->obj), columns, rows); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_audible_bell(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "is_audible", NULL }; int is_audible; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_audible_bell", kwlist, &is_audible)) return NULL; vte_terminal_set_audible_bell(VTE_TERMINAL(self->obj), is_audible); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_audible_bell(PyGObject *self) { int ret; ret = vte_terminal_get_audible_bell(VTE_TERMINAL(self->obj)); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_set_visible_bell(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "is_visible", NULL }; int is_visible; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_visible_bell", kwlist, &is_visible)) return NULL; vte_terminal_set_visible_bell(VTE_TERMINAL(self->obj), is_visible); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_visible_bell(PyGObject *self) { int ret; ret = vte_terminal_get_visible_bell(VTE_TERMINAL(self->obj)); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_set_scroll_background(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "scroll", NULL }; int scroll; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_scroll_background", kwlist, &scroll)) return NULL; vte_terminal_set_scroll_background(VTE_TERMINAL(self->obj), scroll); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_scroll_on_output(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "scroll", NULL }; int scroll; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_scroll_on_output", kwlist, &scroll)) return NULL; vte_terminal_set_scroll_on_output(VTE_TERMINAL(self->obj), scroll); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_scroll_on_keystroke(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "scroll", NULL }; int scroll; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_scroll_on_keystroke", kwlist, &scroll)) return NULL; vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(self->obj), scroll); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_color_dim(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "dim", NULL }; PyObject *py_dim; GdkColor *dim = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_color_dim", kwlist, &py_dim)) return NULL; if (pyg_boxed_check(py_dim, GDK_TYPE_COLOR)) dim = pyg_boxed_get(py_dim, GdkColor); else { PyErr_SetString(PyExc_TypeError, "dim should be a GdkColor"); return NULL; } vte_terminal_set_color_dim(VTE_TERMINAL(self->obj), dim); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_color_bold(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "bold", NULL }; PyObject *py_bold; GdkColor *bold = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_color_bold", kwlist, &py_bold)) return NULL; if (pyg_boxed_check(py_bold, GDK_TYPE_COLOR)) bold = pyg_boxed_get(py_bold, GdkColor); else { PyErr_SetString(PyExc_TypeError, "bold should be a GdkColor"); return NULL; } vte_terminal_set_color_bold(VTE_TERMINAL(self->obj), bold); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_color_foreground(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "foreground", NULL }; PyObject *py_foreground; GdkColor *foreground = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_color_foreground", kwlist, &py_foreground)) return NULL; if (pyg_boxed_check(py_foreground, GDK_TYPE_COLOR)) foreground = pyg_boxed_get(py_foreground, GdkColor); else { PyErr_SetString(PyExc_TypeError, "foreground should be a GdkColor"); return NULL; } vte_terminal_set_color_foreground(VTE_TERMINAL(self->obj), foreground); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_color_background(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "background", NULL }; PyObject *py_background; GdkColor *background = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_color_background", kwlist, &py_background)) return NULL; if (pyg_boxed_check(py_background, GDK_TYPE_COLOR)) background = pyg_boxed_get(py_background, GdkColor); else { PyErr_SetString(PyExc_TypeError, "background should be a GdkColor"); return NULL; } vte_terminal_set_color_background(VTE_TERMINAL(self->obj), background); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_color_cursor(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "cursor_background", NULL }; PyObject *py_cursor_background; GdkColor *cursor_background = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_color_cursor", kwlist, &py_cursor_background)) return NULL; if (pyg_boxed_check(py_cursor_background, GDK_TYPE_COLOR)) cursor_background = pyg_boxed_get(py_cursor_background, GdkColor); else { PyErr_SetString(PyExc_TypeError, "cursor_background should be a GdkColor"); return NULL; } vte_terminal_set_color_cursor(VTE_TERMINAL(self->obj), cursor_background); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_color_highlight(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "highlight_background", NULL }; PyObject *py_highlight_background; GdkColor *highlight_background = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_color_highlight", kwlist, &py_highlight_background)) return NULL; if (pyg_boxed_check(py_highlight_background, GDK_TYPE_COLOR)) highlight_background = pyg_boxed_get(py_highlight_background, GdkColor); else { PyErr_SetString(PyExc_TypeError, "highlight_background should be a GdkColor"); return NULL; } vte_terminal_set_color_highlight(VTE_TERMINAL(self->obj), highlight_background); Py_INCREF(Py_None); return Py_None; } #line 461 "vte.override" static PyObject * _wrap_vte_terminal_set_colors(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "foreground", "background", "palette", NULL }; PyObject *py_foreground, *py_background, *py_palette, *item; int palette_size, i; GdkColor *foreground = NULL, *background = NULL, *palette = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VteTerminal.set_colors", kwlist, &py_foreground, &py_background, &py_palette, &palette_size)) return NULL; if (pyg_boxed_check(py_foreground, GDK_TYPE_COLOR)) foreground = pyg_boxed_get(py_foreground, GdkColor); else { PyErr_SetString(PyExc_TypeError, "foreground should be a GdkColor"); return NULL; } if (pyg_boxed_check(py_background, GDK_TYPE_COLOR)) background = pyg_boxed_get(py_background, GdkColor); else { PyErr_SetString(PyExc_TypeError, "background should be a GdkColor"); return NULL; } if (PySequence_Check(py_palette)) { palette_size = PySequence_Length(py_palette); palette = g_malloc(sizeof(GdkColor) * palette_size); for (i = 0; i < palette_size; i++) { item = PySequence_GetItem(py_palette, i); /* INCREFs */ if (!pyg_boxed_check(item, GDK_TYPE_COLOR)) { g_free(palette); PyErr_SetString(PyExc_TypeError, "palette should be a list of GdkColors"); return NULL; } palette[i] = *((GdkColor*)pyg_boxed_get(item, GdkColor)); Py_DECREF(item); } } else { PyErr_SetString(PyExc_TypeError, "palette should be a list of GdkColors"); return NULL; } vte_terminal_set_colors(VTE_TERMINAL(self->obj), foreground, background, palette, palette_size); g_free(palette); Py_INCREF(Py_None); return Py_None; } #line 489 "vte.c" static PyObject * _wrap_vte_terminal_set_default_colors(PyGObject *self) { vte_terminal_set_default_colors(VTE_TERMINAL(self->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_background_image(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "image", NULL }; PyGObject *image; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:VteTerminal.set_background_image", kwlist, &PyGdkPixbuf_Type, &image)) return NULL; vte_terminal_set_background_image(VTE_TERMINAL(self->obj), GDK_PIXBUF(image->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_background_image_file(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "path", NULL }; char *path; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:VteTerminal.set_background_image_file", kwlist, &path)) return NULL; vte_terminal_set_background_image_file(VTE_TERMINAL(self->obj), path); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_background_tint_color(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "color", NULL }; PyObject *py_color; GdkColor *color = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_background_tint_color", kwlist, &py_color)) return NULL; if (pyg_boxed_check(py_color, GDK_TYPE_COLOR)) color = pyg_boxed_get(py_color, GdkColor); else { PyErr_SetString(PyExc_TypeError, "color should be a GdkColor"); return NULL; } vte_terminal_set_background_tint_color(VTE_TERMINAL(self->obj), color); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_background_saturation(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "saturation", NULL }; double saturation; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d:VteTerminal.set_background_saturation", kwlist, &saturation)) return NULL; vte_terminal_set_background_saturation(VTE_TERMINAL(self->obj), saturation); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_background_transparent(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "transparent", NULL }; int transparent; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_background_transparent", kwlist, &transparent)) return NULL; vte_terminal_set_background_transparent(VTE_TERMINAL(self->obj), transparent); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_cursor_blinks(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "blink", NULL }; int blink; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_cursor_blinks", kwlist, &blink)) return NULL; vte_terminal_set_cursor_blinks(VTE_TERMINAL(self->obj), blink); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_scrollback_lines(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "lines", NULL }; glong lines; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "l:VteTerminal.set_scrollback_lines", kwlist, &lines)) return NULL; vte_terminal_set_scrollback_lines(VTE_TERMINAL(self->obj), lines); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_im_append_menuitems(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "menushell", NULL }; PyGObject *menushell; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:VteTerminal.im_append_menuitems", kwlist, &PyGtkMenuShell_Type, &menushell)) return NULL; vte_terminal_im_append_menuitems(VTE_TERMINAL(self->obj), GTK_MENU_SHELL(menushell->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_font(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "font_desc", NULL }; PyObject *py_font_desc; PangoFontDescription *font_desc = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_font", kwlist, &py_font_desc)) return NULL; if (pyg_boxed_check(py_font_desc, PANGO_TYPE_FONT_DESCRIPTION)) font_desc = pyg_boxed_get(py_font_desc, PangoFontDescription); else { PyErr_SetString(PyExc_TypeError, "font_desc should be a PangoFontDescription"); return NULL; } vte_terminal_set_font(VTE_TERMINAL(self->obj), font_desc); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_font_full(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "font_desc", "antialias", NULL }; PyObject *py_font_desc, *py_antialias = NULL; PangoFontDescription *font_desc = NULL; VteTerminalAntiAlias antialias; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VteTerminal.set_font_full", kwlist, &py_font_desc, &py_antialias)) return NULL; if (pyg_boxed_check(py_font_desc, PANGO_TYPE_FONT_DESCRIPTION)) font_desc = pyg_boxed_get(py_font_desc, PangoFontDescription); else { PyErr_SetString(PyExc_TypeError, "font_desc should be a PangoFontDescription"); return NULL; } if (pyg_enum_get_value(VTE_TYPE_TERMINAL_ANTI_ALIAS, py_antialias, (gint *)&antialias)) return NULL; vte_terminal_set_font_full(VTE_TERMINAL(self->obj), font_desc, antialias); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_font_from_string(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "name", NULL }; char *name; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:VteTerminal.set_font_from_string", kwlist, &name)) return NULL; vte_terminal_set_font_from_string(VTE_TERMINAL(self->obj), name); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_font_from_string_full(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "name", "antialias", NULL }; char *name; PyObject *py_antialias = NULL; VteTerminalAntiAlias antialias; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO:VteTerminal.set_font_from_string_full", kwlist, &name, &py_antialias)) return NULL; if (pyg_enum_get_value(VTE_TYPE_TERMINAL_ANTI_ALIAS, py_antialias, (gint *)&antialias)) return NULL; vte_terminal_set_font_from_string_full(VTE_TERMINAL(self->obj), name, antialias); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_font(PyGObject *self) { PangoFontDescription *ret; ret = vte_terminal_get_font(VTE_TERMINAL(self->obj)); /* pyg_boxed_new handles NULL checking */ return pyg_boxed_new(PANGO_TYPE_FONT_DESCRIPTION, ret, TRUE, TRUE); } static PyObject * _wrap_vte_terminal_get_using_xft(PyGObject *self) { int ret; ret = vte_terminal_get_using_xft(VTE_TERMINAL(self->obj)); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_set_allow_bold(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "allow_bold", NULL }; int allow_bold; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_allow_bold", kwlist, &allow_bold)) return NULL; vte_terminal_set_allow_bold(VTE_TERMINAL(self->obj), allow_bold); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_allow_bold(PyGObject *self) { int ret; ret = vte_terminal_get_allow_bold(VTE_TERMINAL(self->obj)); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_has_selection(PyGObject *self) { int ret; ret = vte_terminal_get_has_selection(VTE_TERMINAL(self->obj)); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_set_word_chars(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "spec", NULL }; char *spec; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:VteTerminal.set_word_chars", kwlist, &spec)) return NULL; vte_terminal_set_word_chars(VTE_TERMINAL(self->obj), spec); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_is_word_char(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "c", NULL }; int ret; gunichar c; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&:VteTerminal.is_word_char", kwlist, pyg_pyobj_to_unichar_conv, &c)) return NULL; ret = vte_terminal_is_word_char(VTE_TERMINAL(self->obj), c); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_set_backspace_binding(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "binding", NULL }; PyObject *py_binding = NULL; VteTerminalEraseBinding binding; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_backspace_binding", kwlist, &py_binding)) return NULL; if (pyg_enum_get_value(VTE_TYPE_TERMINAL_ERASE_BINDING, py_binding, (gint *)&binding)) return NULL; vte_terminal_set_backspace_binding(VTE_TERMINAL(self->obj), binding); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_delete_binding(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "binding", NULL }; PyObject *py_binding = NULL; VteTerminalEraseBinding binding; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:VteTerminal.set_delete_binding", kwlist, &py_binding)) return NULL; if (pyg_enum_get_value(VTE_TYPE_TERMINAL_ERASE_BINDING, py_binding, (gint *)&binding)) return NULL; vte_terminal_set_delete_binding(VTE_TERMINAL(self->obj), binding); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_mouse_autohide(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "setting", NULL }; int setting; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.set_mouse_autohide", kwlist, &setting)) return NULL; vte_terminal_set_mouse_autohide(VTE_TERMINAL(self->obj), setting); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_mouse_autohide(PyGObject *self) { int ret; ret = vte_terminal_get_mouse_autohide(VTE_TERMINAL(self->obj)); return PyBool_FromLong(ret); } static PyObject * _wrap_vte_terminal_reset(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "full", "clear_history", NULL }; int full, clear_history; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii:VteTerminal.reset", kwlist, &full, &clear_history)) return NULL; vte_terminal_reset(VTE_TERMINAL(self->obj), full, clear_history); Py_INCREF(Py_None); return Py_None; } #line 235 "vte.override" static gboolean call_callback(VteTerminal *terminal, glong column, glong row, gpointer data) { PyObject *cb, *args, *result; gboolean ret; if (!PySequence_Check(data)) { PyErr_SetString(PyExc_TypeError, "expected argument list in a tuple"); return FALSE; } cb = PySequence_GetItem(data, 0); /* INCREFs */ Py_XDECREF(cb); if (!PyCallable_Check(cb)) { PyErr_SetString(PyExc_TypeError, "callback is not a callable object"); return FALSE; } args = PyTuple_New(4); PyTuple_SetItem(args, 0, PySequence_GetItem(data, 1)); PyTuple_SetItem(args, 1, PyInt_FromLong(column)); PyTuple_SetItem(args, 2, PyInt_FromLong(row)); PyTuple_SetItem(args, 3, PySequence_GetItem(data, 2)); result = PyObject_CallObject(cb, args); Py_DECREF(args); ret = (result && PyObject_IsTrue(result)); Py_XDECREF(result); return ret; } static gboolean always_true(VteTerminal *terminal, glong row, glong column, gpointer data) { return TRUE; } static PyObject * _wrap_vte_terminal_get_text(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "callback", "get_attributes", "data", NULL }; PyObject *callback = NULL, *do_attr = NULL, *data = NULL; PyObject *callback_and_args = NULL; GArray *attrs = NULL; char *text; PyObject *py_attrs; int count; long length; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:terminal_get_text", kwlist, &callback, &do_attr, &data)) { return NULL; } if ((do_attr != NULL) && (PyObject_IsTrue(do_attr))) { attrs = g_array_new(FALSE, TRUE, sizeof(VteCharAttributes)); } else { attrs = NULL; } if (callback != NULL) { if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "1st argument not callable."); if (attrs) { g_array_free(attrs, TRUE); } return NULL; } callback_and_args = PyTuple_New(3); Py_INCREF(callback); /* PyTuple_SetItem will assume ownership. */ PyTuple_SetItem(callback_and_args, 0, callback); Py_INCREF(self); /* PyTuple_SetItem will assume ownership. */ PyTuple_SetItem(callback_and_args, 1, (PyObject*) self); if (data != NULL) { Py_INCREF(data); /* PyTuple_SetItem will assume ownership. */ PyTuple_SetItem(callback_and_args, 2, data); } else { PyTuple_SetItem(callback_and_args, 2, PyTuple_New(0)); } text = vte_terminal_get_text(VTE_TERMINAL(self->obj), call_callback, callback_and_args, attrs); Py_DECREF(callback_and_args); } else { text = vte_terminal_get_text(VTE_TERMINAL(self->obj), always_true, NULL, attrs); } if (attrs) { py_attrs = PyTuple_New(attrs->len); for (count = 0; count < attrs->len; count++) { VteCharAttributes *cht; PyObject *py_char_attr; PyObject *py_gdkcolor; cht = &g_array_index(attrs, VteCharAttributes, count); py_char_attr = PyDict_New(); PyDict_SetItemString(py_char_attr, "row", PyInt_FromLong(cht->row)); PyDict_SetItemString(py_char_attr, "column", PyInt_FromLong(cht->column)); py_gdkcolor = pyg_boxed_new(GDK_TYPE_COLOR, &cht->fore, TRUE, TRUE); PyDict_SetItemString(py_char_attr, "fore", py_gdkcolor); py_gdkcolor = pyg_boxed_new(GDK_TYPE_COLOR, &cht->back, TRUE, TRUE); PyDict_SetItemString(py_char_attr, "back", py_gdkcolor); PyDict_SetItemString(py_char_attr, "underline", PyInt_FromLong(cht->underline)); PyDict_SetItemString(py_char_attr, "strikethrough", PyInt_FromLong(cht->strikethrough)); PyTuple_SetItem(py_attrs, count, py_char_attr); } length = attrs->len; g_array_free(attrs, TRUE); return Py_BuildValue("(s#O)", text, length, py_attrs); } else { return Py_BuildValue("s", text); } } #line 960 "vte.c" #line 364 "vte.override" static PyObject * _wrap_vte_terminal_get_text_range(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "start_row", "start_col", "end_row", "end_col", "callback", "get_attributes", "data", NULL }; PyObject *callback = NULL, *do_attr = NULL, *data = NULL; glong start_row, start_col, end_row, end_col; PyObject *callback_and_args = NULL; GArray *attrs = NULL; char *text; PyObject *py_attrs; int count; long length; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "llllO|OO:terminal_get_text_range", kwlist, &start_row, &start_col, &end_row, &end_col, &callback, &do_attr, &data)) { return NULL; } if ((do_attr != NULL) && (PyObject_IsTrue(do_attr))) { attrs = g_array_new(FALSE, TRUE, sizeof(VteCharAttributes)); } else { attrs = NULL; } if (callback != NULL) { if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "1st argument not callable."); if (attrs) { g_array_free(attrs, TRUE); } return NULL; } callback_and_args = PyTuple_New(3); Py_INCREF(callback); /* PyTuple_SetItem will assume ownership. */ PyTuple_SetItem(callback_and_args, 0, callback); Py_INCREF(self); /* PyTuple_SetItem will assume ownership. */ PyTuple_SetItem(callback_and_args, 1, (PyObject*) self); if (data != NULL) { Py_INCREF(data); /* PyTuple_SetItem will assume ownership. */ PyTuple_SetItem(callback_and_args, 2, data); } else { PyTuple_SetItem(callback_and_args, 2, PyTuple_New(0)); } text = vte_terminal_get_text_range(VTE_TERMINAL(self->obj), start_row, start_col, end_row, end_col, call_callback, callback_and_args, attrs); Py_DECREF(callback_and_args); } else { text = vte_terminal_get_text_range(VTE_TERMINAL(self->obj), start_row, start_col, end_row, end_col, always_true, NULL, attrs); } if (attrs) { py_attrs = PyTuple_New(attrs->len); for (count = 0; count < attrs->len; count++) { VteCharAttributes *cht; PyObject *py_char_attr; PyObject *py_gdkcolor; cht = &g_array_index(attrs, VteCharAttributes, count); py_char_attr = PyDict_New(); PyDict_SetItemString(py_char_attr, "row", PyInt_FromLong(cht->row)); PyDict_SetItemString(py_char_attr, "column", PyInt_FromLong(cht->column)); py_gdkcolor = pyg_boxed_new(GDK_TYPE_COLOR, &cht->fore, TRUE, TRUE); PyDict_SetItemString(py_char_attr, "fore", py_gdkcolor); py_gdkcolor = pyg_boxed_new(GDK_TYPE_COLOR, &cht->back, TRUE, TRUE); PyDict_SetItemString(py_char_attr, "back", py_gdkcolor); PyDict_SetItemString(py_char_attr, "underline", PyInt_FromLong(cht->underline)); PyDict_SetItemString(py_char_attr, "strikethrough", PyInt_FromLong(cht->strikethrough)); PyTuple_SetItem(py_attrs, count, py_char_attr); } length = attrs->len; g_array_free(attrs, TRUE); return Py_BuildValue("(s#O)", text, length, py_attrs); } else { return Py_BuildValue("s", text); } } #line 1059 "vte.c" #line 204 "vte.override" static PyObject * _wrap_vte_terminal_get_cursor_position(PyGObject *self) { PyObject *ret; glong column, row; vte_terminal_get_cursor_position(VTE_TERMINAL(self->obj), &column, &row); ret = PyTuple_New(2); PyTuple_SetItem(ret, 0, PyInt_FromLong(column)); PyTuple_SetItem(ret, 1, PyInt_FromLong(row)); return ret; } #line 1077 "vte.c" static PyObject * _wrap_vte_terminal_match_clear_all(PyGObject *self) { vte_terminal_match_clear_all(VTE_TERMINAL(self->obj)); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_match_add(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "match", NULL }; char *match; int ret; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:VteTerminal.match_add", kwlist, &match)) return NULL; ret = vte_terminal_match_add(VTE_TERMINAL(self->obj), match); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_match_set_cursor(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "tag", "cursor", NULL }; int tag; PyObject *py_cursor; GdkCursor *cursor = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iO:VteTerminal.match_set_cursor", kwlist, &tag, &py_cursor)) return NULL; if (pyg_boxed_check(py_cursor, GDK_TYPE_CURSOR)) cursor = pyg_boxed_get(py_cursor, GdkCursor); else { PyErr_SetString(PyExc_TypeError, "cursor should be a GdkCursor"); return NULL; } vte_terminal_match_set_cursor(VTE_TERMINAL(self->obj), tag, cursor); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_match_set_cursor_type(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "tag", "cursor_type", NULL }; int tag; PyObject *py_cursor_type = NULL; GdkCursorType cursor_type; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iO:VteTerminal.match_set_cursor_type", kwlist, &tag, &py_cursor_type)) return NULL; if (pyg_enum_get_value(GDK_TYPE_CURSOR_TYPE, py_cursor_type, (gint *)&cursor_type)) return NULL; vte_terminal_match_set_cursor_type(VTE_TERMINAL(self->obj), tag, cursor_type); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_match_remove(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "tag", NULL }; int tag; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i:VteTerminal.match_remove", kwlist, &tag)) return NULL; vte_terminal_match_remove(VTE_TERMINAL(self->obj), tag); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_emulation(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "emulation", NULL }; char *emulation; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:VteTerminal.set_emulation", kwlist, &emulation)) return NULL; vte_terminal_set_emulation(VTE_TERMINAL(self->obj), emulation); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_emulation(PyGObject *self) { const gchar *ret; ret = vte_terminal_get_emulation(VTE_TERMINAL(self->obj)); if (ret) return PyString_FromString(ret); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_default_emulation(PyGObject *self) { const gchar *ret; ret = vte_terminal_get_default_emulation(VTE_TERMINAL(self->obj)); if (ret) return PyString_FromString(ret); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_set_encoding(PyGObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "codeset", NULL }; char *codeset; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:VteTerminal.set_encoding", kwlist, &codeset)) return NULL; vte_terminal_set_encoding(VTE_TERMINAL(self->obj), codeset); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_encoding(PyGObject *self) { const gchar *ret; ret = vte_terminal_get_encoding(VTE_TERMINAL(self->obj)); if (ret) return PyString_FromString(ret); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_status_line(PyGObject *self) { const gchar *ret; ret = vte_terminal_get_status_line(VTE_TERMINAL(self->obj)); if (ret) return PyString_FromString(ret); Py_INCREF(Py_None); return Py_None; } #line 220 "vte.override" static PyObject * _wrap_vte_terminal_get_padding(PyGObject *self) { PyObject *ret; int xpad, ypad; vte_terminal_get_padding(VTE_TERMINAL(self->obj), &xpad, &ypad); ret = PyTuple_New(2); PyTuple_SetItem(ret, 0, PyInt_FromLong(xpad)); PyTuple_SetItem(ret, 1, PyInt_FromLong(ypad)); return ret; } #line 1240 "vte.c" static PyObject * _wrap_vte_terminal_get_adjustment(PyGObject *self) { GtkAdjustment *ret; ret = vte_terminal_get_adjustment(VTE_TERMINAL(self->obj)); /* pygobject_new handles NULL checking */ return pygobject_new((GObject *)ret); } static PyObject * _wrap_vte_terminal_get_char_width(PyGObject *self) { glong ret; ret = vte_terminal_get_char_width(VTE_TERMINAL(self->obj)); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_char_height(PyGObject *self) { glong ret; ret = vte_terminal_get_char_height(VTE_TERMINAL(self->obj)); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_char_descent(PyGObject *self) { glong ret; ret = vte_terminal_get_char_descent(VTE_TERMINAL(self->obj)); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_char_ascent(PyGObject *self) { glong ret; ret = vte_terminal_get_char_ascent(VTE_TERMINAL(self->obj)); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_row_count(PyGObject *self) { glong ret; ret = vte_terminal_get_row_count(VTE_TERMINAL(self->obj)); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_column_count(PyGObject *self) { glong ret; ret = vte_terminal_get_column_count(VTE_TERMINAL(self->obj)); return PyInt_FromLong(ret); } static PyObject * _wrap_vte_terminal_get_window_title(PyGObject *self) { const gchar *ret; ret = vte_terminal_get_window_title(VTE_TERMINAL(self->obj)); if (ret) return PyString_FromString(ret); Py_INCREF(Py_None); return Py_None; } static PyObject * _wrap_vte_terminal_get_icon_title(PyGObject *self) { const gchar *ret; ret = vte_terminal_get_icon_title(VTE_TERMINAL(self->obj)); if (ret) return PyString_FromString(ret); Py_INCREF(Py_None); return Py_None; } static PyMethodDef _PyVteTerminal_methods[] = { { "fork_command", (PyCFunction)_wrap_vte_terminal_fork_command, METH_VARARGS|METH_KEYWORDS }, { "feed", (PyCFunction)_wrap_vte_terminal_feed, METH_VARARGS|METH_KEYWORDS }, { "feed_child", (PyCFunction)_wrap_vte_terminal_feed_child, METH_VARARGS|METH_KEYWORDS }, { "copy_clipboard", (PyCFunction)_wrap_vte_terminal_copy_clipboard, METH_NOARGS }, { "paste_clipboard", (PyCFunction)_wrap_vte_terminal_paste_clipboard, METH_NOARGS }, { "copy_primary", (PyCFunction)_wrap_vte_terminal_copy_primary, METH_NOARGS }, { "paste_primary", (PyCFunction)_wrap_vte_terminal_paste_primary, METH_NOARGS }, { "set_size", (PyCFunction)_wrap_vte_terminal_set_size, METH_VARARGS|METH_KEYWORDS }, { "set_audible_bell", (PyCFunction)_wrap_vte_terminal_set_audible_bell, METH_VARARGS|METH_KEYWORDS }, { "get_audible_bell", (PyCFunction)_wrap_vte_terminal_get_audible_bell, METH_NOARGS }, { "set_visible_bell", (PyCFunction)_wrap_vte_terminal_set_visible_bell, METH_VARARGS|METH_KEYWORDS }, { "get_visible_bell", (PyCFunction)_wrap_vte_terminal_get_visible_bell, METH_NOARGS }, { "set_scroll_background", (PyCFunction)_wrap_vte_terminal_set_scroll_background, METH_VARARGS|METH_KEYWORDS }, { "set_scroll_on_output", (PyCFunction)_wrap_vte_terminal_set_scroll_on_output, METH_VARARGS|METH_KEYWORDS }, { "set_scroll_on_keystroke", (PyCFunction)_wrap_vte_terminal_set_scroll_on_keystroke, METH_VARARGS|METH_KEYWORDS }, { "set_color_dim", (PyCFunction)_wrap_vte_terminal_set_color_dim, METH_VARARGS|METH_KEYWORDS }, { "set_color_bold", (PyCFunction)_wrap_vte_terminal_set_color_bold, METH_VARARGS|METH_KEYWORDS }, { "set_color_foreground", (PyCFunction)_wrap_vte_terminal_set_color_foreground, METH_VARARGS|METH_KEYWORDS }, { "set_color_background", (PyCFunction)_wrap_vte_terminal_set_color_background, METH_VARARGS|METH_KEYWORDS }, { "set_color_cursor", (PyCFunction)_wrap_vte_terminal_set_color_cursor, METH_VARARGS|METH_KEYWORDS }, { "set_color_highlight", (PyCFunction)_wrap_vte_terminal_set_color_highlight, METH_VARARGS|METH_KEYWORDS }, { "set_colors", (PyCFunction)_wrap_vte_terminal_set_colors, METH_VARARGS|METH_KEYWORDS }, { "set_default_colors", (PyCFunction)_wrap_vte_terminal_set_default_colors, METH_NOARGS }, { "set_background_image", (PyCFunction)_wrap_vte_terminal_set_background_image, METH_VARARGS|METH_KEYWORDS }, { "set_background_image_file", (PyCFunction)_wrap_vte_terminal_set_background_image_file, METH_VARARGS|METH_KEYWORDS }, { "set_background_tint_color", (PyCFunction)_wrap_vte_terminal_set_background_tint_color, METH_VARARGS|METH_KEYWORDS }, { "set_background_saturation", (PyCFunction)_wrap_vte_terminal_set_background_saturation, METH_VARARGS|METH_KEYWORDS }, { "set_background_transparent", (PyCFunction)_wrap_vte_terminal_set_background_transparent, METH_VARARGS|METH_KEYWORDS }, { "set_cursor_blinks", (PyCFunction)_wrap_vte_terminal_set_cursor_blinks, METH_VARARGS|METH_KEYWORDS }, { "set_scrollback_lines", (PyCFunction)_wrap_vte_terminal_set_scrollback_lines, METH_VARARGS|METH_KEYWORDS }, { "im_append_menuitems", (PyCFunction)_wrap_vte_terminal_im_append_menuitems, METH_VARARGS|METH_KEYWORDS }, { "set_font", (PyCFunction)_wrap_vte_terminal_set_font, METH_VARARGS|METH_KEYWORDS }, { "set_font_full", (PyCFunction)_wrap_vte_terminal_set_font_full, METH_VARARGS|METH_KEYWORDS }, { "set_font_from_string", (PyCFunction)_wrap_vte_terminal_set_font_from_string, METH_VARARGS|METH_KEYWORDS }, { "set_font_from_string_full", (PyCFunction)_wrap_vte_terminal_set_font_from_string_full, METH_VARARGS|METH_KEYWORDS }, { "get_font", (PyCFunction)_wrap_vte_terminal_get_font, METH_NOARGS }, { "get_using_xft", (PyCFunction)_wrap_vte_terminal_get_using_xft, METH_NOARGS }, { "set_allow_bold", (PyCFunction)_wrap_vte_terminal_set_allow_bold, METH_VARARGS|METH_KEYWORDS }, { "get_allow_bold", (PyCFunction)_wrap_vte_terminal_get_allow_bold, METH_NOARGS }, { "get_has_selection", (PyCFunction)_wrap_vte_terminal_get_has_selection, METH_NOARGS }, { "set_word_chars", (PyCFunction)_wrap_vte_terminal_set_word_chars, METH_VARARGS|METH_KEYWORDS }, { "is_word_char", (PyCFunction)_wrap_vte_terminal_is_word_char, METH_VARARGS|METH_KEYWORDS }, { "set_backspace_binding", (PyCFunction)_wrap_vte_terminal_set_backspace_binding, METH_VARARGS|METH_KEYWORDS }, { "set_delete_binding", (PyCFunction)_wrap_vte_terminal_set_delete_binding, METH_VARARGS|METH_KEYWORDS }, { "set_mouse_autohide", (PyCFunction)_wrap_vte_terminal_set_mouse_autohide, METH_VARARGS|METH_KEYWORDS }, { "get_mouse_autohide", (PyCFunction)_wrap_vte_terminal_get_mouse_autohide, METH_NOARGS }, { "reset", (PyCFunction)_wrap_vte_terminal_reset, METH_VARARGS|METH_KEYWORDS }, { "get_text", (PyCFunction)_wrap_vte_terminal_get_text, METH_VARARGS|METH_KEYWORDS }, { "get_text_range", (PyCFunction)_wrap_vte_terminal_get_text_range, METH_VARARGS|METH_KEYWORDS }, { "get_cursor_position", (PyCFunction)_wrap_vte_terminal_get_cursor_position, METH_NOARGS }, { "match_clear_all", (PyCFunction)_wrap_vte_terminal_match_clear_all, METH_NOARGS }, { "match_add", (PyCFunction)_wrap_vte_terminal_match_add, METH_VARARGS|METH_KEYWORDS }, { "match_set_cursor", (PyCFunction)_wrap_vte_terminal_match_set_cursor, METH_VARARGS|METH_KEYWORDS }, { "match_set_cursor_type", (PyCFunction)_wrap_vte_terminal_match_set_cursor_type, METH_VARARGS|METH_KEYWORDS }, { "match_remove", (PyCFunction)_wrap_vte_terminal_match_remove, METH_VARARGS|METH_KEYWORDS }, { "set_emulation", (PyCFunction)_wrap_vte_terminal_set_emulation, METH_VARARGS|METH_KEYWORDS }, { "get_emulation", (PyCFunction)_wrap_vte_terminal_get_emulation, METH_NOARGS }, { "get_default_emulation", (PyCFunction)_wrap_vte_terminal_get_default_emulation, METH_NOARGS }, { "set_encoding", (PyCFunction)_wrap_vte_terminal_set_encoding, METH_VARARGS|METH_KEYWORDS }, { "get_encoding", (PyCFunction)_wrap_vte_terminal_get_encoding, METH_NOARGS }, { "get_status_line", (PyCFunction)_wrap_vte_terminal_get_status_line, METH_NOARGS }, { "get_padding", (PyCFunction)_wrap_vte_terminal_get_padding, METH_NOARGS }, { "get_adjustment", (PyCFunction)_wrap_vte_terminal_get_adjustment, METH_NOARGS }, { "get_char_width", (PyCFunction)_wrap_vte_terminal_get_char_width, METH_NOARGS }, { "get_char_height", (PyCFunction)_wrap_vte_terminal_get_char_height, METH_NOARGS }, { "get_char_descent", (PyCFunction)_wrap_vte_terminal_get_char_descent, METH_NOARGS }, { "get_char_ascent", (PyCFunction)_wrap_vte_terminal_get_char_ascent, METH_NOARGS }, { "get_row_count", (PyCFunction)_wrap_vte_terminal_get_row_count, METH_NOARGS }, { "get_column_count", (PyCFunction)_wrap_vte_terminal_get_column_count, METH_NOARGS }, { "get_window_title", (PyCFunction)_wrap_vte_terminal_get_window_title, METH_NOARGS }, { "get_icon_title", (PyCFunction)_wrap_vte_terminal_get_icon_title, METH_NOARGS }, { NULL, NULL, 0 } }; PyTypeObject PyVteTerminal_Type = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ "vte.Terminal", /* 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 */ _PyVteTerminal_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_vte_terminal_new, /* tp_init */ (allocfunc)0, /* tp_alloc */ (newfunc)0, /* tp_new */ (freefunc)0, /* tp_free */ (inquiry)0 /* tp_is_gc */ }; /* ----------- functions ----------- */ static PyObject * _wrap_vte_terminal_get_type(PyObject *self) { GType ret; ret = vte_terminal_get_type(); return pyg_type_wrapper_new(ret); } static PyObject * _wrap_vte_terminal_erase_binding_get_type(PyObject *self) { GType ret; ret = vte_terminal_erase_binding_get_type(); return pyg_type_wrapper_new(ret); } static PyObject * _wrap_vte_terminal_anti_alias_get_type(PyObject *self) { GType ret; ret = vte_terminal_anti_alias_get_type(); return pyg_type_wrapper_new(ret); } PyMethodDef pyvte_functions[] = { { "vte_terminal_get_type", (PyCFunction)_wrap_vte_terminal_get_type, METH_NOARGS }, { "vte_terminal_erase_binding_get_type", (PyCFunction)_wrap_vte_terminal_erase_binding_get_type, METH_NOARGS }, { "vte_terminal_anti_alias_get_type", (PyCFunction)_wrap_vte_terminal_anti_alias_get_type, METH_NOARGS }, { NULL, NULL, 0 } }; /* ----------- enums and flags ----------- */ void pyvte_add_constants(PyObject *module, const gchar *strip_prefix) { pyg_enum_add(module, "TerminalEraseBinding", strip_prefix, VTE_TYPE_TERMINAL_ERASE_BINDING); pyg_enum_add(module, "TerminalAntiAlias", strip_prefix, VTE_TYPE_TERMINAL_ANTI_ALIAS); if (PyErr_Occurred()) PyErr_Print(); } /* initialise stuff extension classes */ void pyvte_register_classes(PyObject *d) { PyObject *module; if ((module = PyImport_ImportModule("gtk")) != NULL) { PyObject *moddict = PyModule_GetDict(module); _PyGtkMenuShell_Type = (PyTypeObject *)PyDict_GetItemString(moddict, "MenuShell"); if (_PyGtkMenuShell_Type == NULL) { PyErr_SetString(PyExc_ImportError, "cannot import name MenuShell from gtk"); return; } _PyGtkWidget_Type = (PyTypeObject *)PyDict_GetItemString(moddict, "Widget"); if (_PyGtkWidget_Type == NULL) { PyErr_SetString(PyExc_ImportError, "cannot import name Widget from gtk"); return; } } else { PyErr_SetString(PyExc_ImportError, "could not import gtk"); return; } if ((module = PyImport_ImportModule("gtk.gdk")) != NULL) { PyObject *moddict = PyModule_GetDict(module); _PyGdkPixbuf_Type = (PyTypeObject *)PyDict_GetItemString(moddict, "Pixbuf"); if (_PyGdkPixbuf_Type == NULL) { PyErr_SetString(PyExc_ImportError, "cannot import name Pixbuf from gtk.gdk"); return; } } else { PyErr_SetString(PyExc_ImportError, "could not import gtk.gdk"); return; } #line 1550 "vte.c" pygobject_register_class(d, "VteTerminal", VTE_TYPE_TERMINAL, &PyVteTerminal_Type, Py_BuildValue("(O)", &PyGtkWidget_Type)); }