diff --git a/Makefile.am b/Makefile.am index c4d7ae05ba..f32edf7f4d 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,6 +1,6 @@ DISTCHECK_CONFIGURE_FLAGS=--enable-gtk-doc -SUBDIRS = ges tests tools common m4 pkgconfig docs bindings +SUBDIRS = ges tests tools common m4 pkgconfig docs DIST_SUBDIRS = $(SUBDIRS) diff --git a/bindings/Makefile.am b/bindings/Makefile.am deleted file mode 100644 index 65cca14176..0000000000 --- a/bindings/Makefile.am +++ /dev/null @@ -1,5 +0,0 @@ -SUBDIRS = - -if WITH_PYTHON - SUBDIRS += python -endif diff --git a/bindings/python/Makefile.am b/bindings/python/Makefile.am deleted file mode 100644 index c696c2da72..0000000000 --- a/bindings/python/Makefile.am +++ /dev/null @@ -1,42 +0,0 @@ -SUBDIRS = codegen examples testsuite -pkgpyexecdir = $(pyexecdir) - -# we install everything in pyexecdir; otherwise you end up with a mess for -# multilib -pygesdir = $(pkgpyexecdir) -pyges_PYTHON = - -pygesexecdir = $(pkgpyexecdir) -pygesexec_LTLIBRARIES = ges.la - -DEFS = $(srcdir)/ges-types.defs $(srcdir)/ges.defs -defs_DATA = $(DEFS) -defsdir = $(pkgdatadir)/$(GST_MAJORMINOR)/defs -OVERRIDES = ges.override - -INCLUDES = -I$(top_srcdir) -I$(srcdir) $(PYTHON_INCLUDES) - -ges_la_CFLAGS = -I$(top_srcdir)\ - $(PYGOBJECT_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) $(GST_CFLAGS) -Wno-write-strings -ges_la_LDFLAGS = -export-symbols-regex "^(initges|_PyGObject_API).*" \ - -module -avoid-version $(GST_PLUGIN_LDFLAGS) -ges_la_LIBADD = $(top_builddir)/ges/libges-@GST_MAJORMINOR@.la \ - $(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS) \ - -lges-@GST_MAJORMINOR@ -lges-@GST_MAJORMINOR@ \ - -lges-@GST_MAJORMINOR@ $(GST_LIBS) $(LIBM) -ges_la_SOURCES = gesmodule.c -nodist_ges_la_SOURCES = ges.c - -EXTRA_DIST = $(defs_DATA) $(OVERRIDES) arg-types.py - -CLEANFILES = ges.c - -.defs.c: - ($(PYTHON) $(srcdir)/codegen/codegen.py \ - --load-types $(srcdir)/arg-types.py \ - --register $(srcdir)/ges-types.defs \ - --override $(srcdir)/$*.override \ - --prefix pyges $<) > gen-$*.c \ - && cp gen-$*.c $*.c \ - && rm -f gen-$*.c - diff --git a/bindings/python/arg-types.py b/bindings/python/arg-types.py deleted file mode 100644 index 5e26ef7388..0000000000 --- a/bindings/python/arg-types.py +++ /dev/null @@ -1,421 +0,0 @@ -# -*- Mode: Python -*- -# vi:si:et:sw=4:sts=4:ts=4 -# -# gst-python -# Copyright (C) 2002 David I. Lehn -# 2004 Johan Dahlin -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Library General Public -# License as published by the Free Software Foundation; either -# version 2 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Library General Public License for more details. -# -# You should have received a copy of the GNU Library General Public -# License along with this library; if not, write to the -# Free Software Foundation, Inc., 59 Temple Place - Suite 330, -# Boston, MA 02111-1307, USA. -# -# Author: David I. Lehn - -from argtypes import UInt64Arg, Int64Arg, PointerArg, ArgMatcher, ArgType, matcher -from reversewrapper import Parameter, ReturnType, GBoxedParam, GBoxedReturn, IntParam, IntReturn - -class XmlNodeArg(ArgType): - """libxml2 node generator""" - - names = {"xobj":"xmlNode", - "xptr":"xmlNodePtr", - "xwrap":"libxml_xmlNodePtrWrap"} - - parm = (' if(xml == NULL) return NULL;\n' - ' xobj = PyObject_GetAttrString(xml, "%(xobj)s");\n' - ' if(!PyObject_IsInstance(py%(name)s, xobj)) {\n' - ' PyErr_Clear();\n' - ' PyErr_SetString(PyExc_RuntimeError,"%(name)s is not a %(xobj)s instance");\n' - ' Py_DECREF(xobj);Py_DECREF(xml);\n' - ' return NULL;\n' - ' }\n' - ' o = PyObject_GetAttrString(py%(name)s, "_o");\n' - ' %(name)s = PyCObject_AsVoidPtr(o);\n') - parmp = (' Py_DECREF(o); Py_DECREF(xobj);Py_DECREF(xml);\n') - - ret = (' if(xml == NULL) return NULL;\n') - retp = (' xargs = PyTuple_New(1);\n' - ' xobj = PyObject_GetAttrString(xml, "%(xobj)s");\n' - ' o = %(xwrap)s(ret);\n' - ' PyTuple_SetItem(xargs, 0, o);\n' - ' return PyInstance_New(xobj, xargs, PyDict_New());\n') - - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('PyObject', '*xml = _gst_get_libxml2_module()') - info.varlist.add('PyObject', '*o') - info.varlist.add('PyObject', '*xobj') - info.varlist.add('PyObject', '*py' + pname) - info.varlist.add(self.names["xptr"], pname) - #if pnull: - info.add_parselist('O', ['&py'+pname], [pname]) - info.arglist.append(pname) - self.names["name"] = pname - info.codebefore.append(self.parm % self.names) - info.codeafter.append(self.parmp % self.names); - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('PyObject', '*xml = _gst_get_libxml2_module()') - info.varlist.add('PyObject', '*xargs') - info.varlist.add('PyObject', '*xobj') - info.varlist.add('PyObject', '*o') - info.varlist.add(self.names["xptr"], 'ret') - info.codebefore.append(self.ret % self.names) - info.codeafter.append(self.retp % self.names) - -class XmlDocArg(XmlNodeArg): - """libxml2 doc generator""" - names = {"xobj":"xmlDoc", - "xptr":"xmlDocPtr", - "xwrap":"libxml_xmlDocPtrWrap"} - -class GstCapsArg(ArgType): - """GstCaps node generator""" - - before = (' %(name)s = pygst_caps_from_pyobject (py_%(name)s, %(namecopy)s);\n' - ' if (PyErr_Occurred())\n' - ' return NULL;\n') - beforenull = (' if (py_%(name)s == Py_None || py_%(name)s == NULL)\n' - ' %(name)s = NULL;\n' - ' else\n' - ' ' + before) - after = (' if (%(name)s && %(name)s_is_copy)\n' - ' gst_caps_unref (%(name)s);\n') - - def write_param(self, ptype, pname, pdflt, pnull, info): - if ptype == 'const-GstCaps*': - self.write_const_param(pname, pdflt, pnull, info) - elif ptype == 'GstCaps*': - self.write_normal_param(pname, pdflt, pnull, info) - else: - raise RuntimeError, "write_param not implemented for %s" % ptype - - def write_const_param(self, pname, pdflt, pnull, info): - if pdflt: - assert pdflt == 'NULL' - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - else: - info.varlist.add('PyObject', '*py_' + pname) - info.varlist.add('GstCaps', '*'+pname) - info.varlist.add('gboolean', pname+'_is_copy') - info.add_parselist('O', ['&py_'+pname], [pname]) - info.arglist.append(pname) - if pnull: - info.codebefore.append (self.beforenull % { 'name' : pname, 'namecopy' : '&'+pname+'_is_copy' }) - else: - info.codebefore.append (self.before % { 'name' : pname, 'namecopy' : '&'+pname+'_is_copy' }) - info.codeafter.append (self.after % { 'name' : pname, 'namecopy' : '&'+pname+'_is_copy' }) - - def write_normal_param(self, pname, pdflt, pnull, info): - if pdflt: - assert pdflt == 'NULL' - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - else: - info.varlist.add('PyObject', '*py_' + pname) - info.varlist.add('GstCaps', '*'+pname) - info.add_parselist('O', ['&py_'+pname], [pname]) - info.arglist.append(pname) - if pnull: - info.codebefore.append (self.beforenull % { 'name' : pname, 'namecopy' : 'NULL' }) - else: - info.codebefore.append (self.before % { 'name' : pname, 'namecopy' : 'NULL' }) - - def write_return(self, ptype, ownsreturn, info): - if ptype == 'GstCaps*': - info.varlist.add('GstCaps', '*ret') - copyval = 'FALSE' - elif ptype == 'const-GstCaps*': - info.varlist.add('const GstCaps', '*ret') - copyval = 'TRUE' - else: - raise RuntimeError, "write_return not implemented for %s" % ptype - info.codeafter.append(' return pyg_boxed_new (GST_TYPE_CAPS, (GstCaps*) ret, '+copyval+', TRUE);') - -class GstIteratorArg(ArgType): - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('GstIterator', '*ret') - info.codeafter.append(' return pygst_iterator_new(ret);') - -class GstMiniObjectArg(ArgType): - - before = (' %(name)s = %(macro)s(pygstminiobject_get (py_%(name)s));\n' - ' if (PyErr_Occurred())\n' - ' return NULL;\n') - - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - assert pdflt == 'NULL' - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - else: - info.varlist.add('PyObject', '*py_' + pname) - - #Converts 'GstBuffer*' to 'GstBuffer' - #and const-GstBuffer* to 'const GstBuffer' - info.varlist.add(ptype.replace('-',' ').replace('*',''), '*'+pname) - - if ptype in ['GstBuffer*', 'const-GstBuffer*']: - info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_BUFFER' }) - - elif ptype in ['GstEncodingProfile*', 'const-GstEncodingProfile*']: - info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_ENCODING_PROFILE' }) - - elif ptype in ['GstMessage*', 'const-GstMessage*']: - info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_MESSAGE' }) - - elif ptype in ['GstEvent*', 'const-GstEvent*']: - info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_EVENT' }) - - elif ptype in ['GstQuery*', 'const-GstQuery*']: - info.codebefore.append(self.before % { 'name' : pname, 'macro' : 'GST_QUERY' }) - - else: - raise RuntimeError, "write_param not implemented for %s" % ptype - - info.add_parselist('O', ['&py_'+pname], [pname]) - info.arglist.append(pname) - - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype, 'ret') - info.codeafter.append(' return pygstminiobject_new((GstMiniObject *) ret);') - -class GstMiniObjectParam(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'GstMiniObject *') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name) - self.wrapper.write_code(code=("if (%s) {\n" - " py_%s = pygstminiobject_new((GstMiniObject *) %s);\n" - " gst_mini_object_unref ((GstMiniObject *) %s);\n" - "} else {\n" - " Py_INCREF(Py_None);\n" - " py_%s = Py_None;\n" - "}" - % (self.name, self.name, self.name, self.name, self.name)), - cleanup=("gst_mini_object_ref ((GstMiniObject *) %s); Py_DECREF(py_%s);" % (self.name, self.name))) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -matcher.register_reverse('GstMiniObject*', GstMiniObjectParam) - -class GstMiniObjectReturn(ReturnType): - - def get_c_type(self): - return self.props.get('c_type', 'GstMiniObject *') - - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - - def write_error_return(self): - self.wrapper.write_code("return NULL;") - - def write_conversion(self): - self.wrapper.write_code("retval = (%s) pygstminiobject_get(py_retval);" - % self.get_c_type()) - self.wrapper.write_code("gst_mini_object_ref((GstMiniObject *) retval);") - -matcher.register_reverse_ret('GstMiniObject*', GstMiniObjectReturn) - -class GstCapsParam(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'GstCaps *') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name) - self.wrapper.write_code(code=("if (%s)\n" - " py_%s = pyg_boxed_new (GST_TYPE_CAPS, %s, FALSE, TRUE);\n" - "else {\n" - " Py_INCREF(Py_None);\n" - " py_%s = Py_None;\n" - "}" - % (self.name, self.name, self.name, self.name)), - cleanup=("gst_caps_ref(%s);\nPy_DECREF(py_%s);" % (self.name, self.name))) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -matcher.register_reverse('GstCaps*', GstCapsParam) - -class GstCapsReturn(ReturnType): - - def get_c_type(self): - return self.props.get('c_type', 'GstCaps *') - - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - - def write_error_return(self): - self.wrapper.write_code("return NULL;") - - def write_conversion(self): - self.wrapper.write_code("retval = (%s) pygst_caps_from_pyobject (py_retval, NULL);" - % self.get_c_type()) -## self.wrapper.write_code("gst_mini_object_ref((GstMiniObject *) retval);") - -matcher.register_reverse_ret('GstCaps*', GstCapsReturn) - - -class Int64Param(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'gint64') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = PyLong_FromLongLong(%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -class Int64Return(ReturnType): - def get_c_type(self): - return self.props.get('c_type', 'gint64') - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - def write_error_return(self): - self.wrapper.write_code("return -G_MAXINT;") - def write_conversion(self): - self.wrapper.write_code( - code=None, - failure_expression="!PyLong_Check(py_retval)", - failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be an long");') - self.wrapper.write_code("retval = PyLong_AsLongLong(py_retval);") - -class UInt64Param(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'guint64') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = PyLong_FromUnsignedLongLong(%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -class UInt64Return(ReturnType): - def get_c_type(self): - return self.props.get('c_type', 'guint64') - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - def write_error_return(self): - self.wrapper.write_code("return -G_MAXINT;") - def write_conversion(self): - self.wrapper.write_code( - code=None, - failure_expression="!PyLong_Check(py_retval)", - failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be an long");') - self.wrapper.write_code("retval = PyLong_AsUnsignedLongLongMask(py_retval);") - -class ULongParam(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'gulong') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = PyLong_FromUnsignedLong(%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -class ULongReturn(ReturnType): - def get_c_type(self): - return self.props.get('c_type', 'gulong') - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - def write_error_return(self): - self.wrapper.write_code("return -G_MAXINT;") - def write_conversion(self): - self.wrapper.write_code( - code=None, - failure_expression="!PyLong_Check(py_retval)", - failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be an long");') - self.wrapper.write_code("retval = PyLong_AsUnsignedLongMask(py_retval);") - -class ConstStringReturn(ReturnType): - - def get_c_type(self): - return "const gchar *" - - def write_decl(self): - self.wrapper.add_declaration("const gchar *retval;") - - def write_error_return(self): - self.wrapper.write_code("return NULL;") - - def write_conversion(self): - self.wrapper.write_code( - code=None, - failure_expression="!PyString_Check(py_retval)", - failure_cleanup='PyErr_SetString(PyExc_TypeError, "retval should be a string");') - self.wrapper.write_code("retval = g_strdup(PyString_AsString(py_retval));") - -class StringArrayArg(ArgType): - """Arg type for NULL-terminated string pointer arrays (GStrv, aka gchar**).""" - def write_return(self, ptype, ownsreturn, info): - if ownsreturn: - raise NotImplementedError () - else: - info.varlist.add("gchar", "**ret") - info.codeafter.append(" if (ret) {\n" - " guint size = g_strv_length(ret);\n" - " PyObject *py_ret = PyTuple_New(size);\n" - " gint i;\n" - " for (i = 0; i < size; i++)\n" - " PyTuple_SetItem(py_ret, i,\n" - " PyString_FromString(ret[i]));\n" - " return py_ret;\n" - " }\n" - " return PyTuple_New (0);\n") - - -matcher.register('GstClockTime', UInt64Arg()) -matcher.register('GstElementFactoryListType', UInt64Arg()) -matcher.register('GstClockTimeDiff', Int64Arg()) -matcher.register('xmlNodePtr', XmlNodeArg()) -matcher.register('xmlDocPtr', XmlDocArg()) -matcher.register('GstCaps', GstCapsArg()) #FIXME: does this work? -matcher.register('GstCaps*', GstCapsArg()) #FIXME: does this work? -matcher.register('const-GstCaps*', GstCapsArg()) -matcher.register('GstIterator*', GstIteratorArg()) - -arg = PointerArg('gpointer', 'G_TYPE_POINTER') -matcher.register('GstClockID', arg) - -for typename in ["GstPlugin", "GstStructure", "GstTagList", "GError", "GstDate", "GstSegment"]: - matcher.register_reverse(typename, GBoxedParam) - matcher.register_reverse_ret(typename, GBoxedReturn) - -for typename in ["GstEncodingProfile*", "cons-GstEncodingProfile", "GstBuffer*", "const-GstBuffer*", "GstEvent*", "const-GstEvent*", "GstMessage*", "const-GstMessage*", "GstQuery*", "const-GstQuery*"]: - matcher.register(typename, GstMiniObjectArg()) - matcher.register_reverse(typename, GstMiniObjectParam) - matcher.register_reverse_ret(typename, GstMiniObjectReturn) - -for typename in ["gint64", "GstClockTimeDiff"]: - matcher.register_reverse(typename, Int64Param) - matcher.register_reverse_ret(typename, Int64Return) - -for typename in ["guint64", "GstClockTime", "GstElementFactoryListType"]: - matcher.register_reverse(typename, UInt64Param) - matcher.register_reverse_ret(typename, UInt64Return) - -matcher.register_reverse_ret("const-gchar*", ConstStringReturn) - -matcher.register_reverse("GType", IntParam) -matcher.register_reverse_ret("GType", IntReturn) - -matcher.register_reverse("gulong", ULongParam) -matcher.register_reverse_ret("gulong", ULongReturn) - -matcher.register("GStrv", StringArrayArg()) - -del arg diff --git a/bindings/python/codegen/Makefile.am b/bindings/python/codegen/Makefile.am deleted file mode 100644 index dd3eea0641..0000000000 --- a/bindings/python/codegen/Makefile.am +++ /dev/null @@ -1,15 +0,0 @@ -EXTRA_DIST = \ - argtypes.py \ - code-coverage.py \ - codegen.py \ - definitions.py \ - defsparser.py \ - docextract.py \ - docgen.py \ - h2def.py \ - __init__.py \ - mergedefs.py \ - mkskel.py \ - override.py \ - reversewrapper.py \ - scmexpr.py diff --git a/bindings/python/codegen/__init__.py b/bindings/python/codegen/__init__.py deleted file mode 100644 index 86188f9600..0000000000 --- a/bindings/python/codegen/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -# -*- Mode: Python; py-indent-offset: 4 -*- - -__all__ = [ - 'argtypes', - 'codegen', - 'definitions', - 'defsparser', - 'docextract', - 'docgen', - 'h2def', - 'defsgen' - 'mergedefs', - 'mkskel', - 'override', - 'scmexpr' -] diff --git a/bindings/python/codegen/argtypes.py b/bindings/python/codegen/argtypes.py deleted file mode 100644 index b1a7de5792..0000000000 --- a/bindings/python/codegen/argtypes.py +++ /dev/null @@ -1,1080 +0,0 @@ -# -*- Mode: Python; py-indent-offset: 4 -*- -import string -import keyword -import struct - -py_ssize_t_clean = False - -class ArgTypeError(Exception): - pass - -class ArgTypeNotFoundError(ArgTypeError): - pass - -class ArgTypeConfigurationError(ArgTypeError): - pass - - -class VarList: - """Nicely format a C variable list""" - def __init__(self): - self.vars = {} - def add(self, ctype, name): - if self.vars.has_key(ctype): - self.vars[ctype] = self.vars[ctype] + (name,) - else: - self.vars[ctype] = (name,) - def __str__(self): - ret = [] - for type in self.vars.keys(): - ret.append(' ') - ret.append(type) - ret.append(' ') - ret.append(string.join(self.vars[type], ', ')) - ret.append(';\n') - if ret: - ret.append('\n') - return string.join(ret, '') - return '' - -class WrapperInfo: - """A class that holds information about variable defs, code - snippets, etcd for use in writing out the function/method - wrapper.""" - def __init__(self): - self.varlist = VarList() - self.parsestr = '' - self.parselist = ['', 'kwlist'] - self.codebefore = [] - self.codeafter = [] - self.arglist = [] - self.kwlist = [] - def get_parselist(self): - return string.join(self.parselist, ', ') - def get_codebefore(self): - return string.join(self.codebefore, '') - def get_codeafter(self): - return string.join(self.codeafter, '') - def get_arglist(self): - return string.join(self.arglist, ', ') - def get_varlist(self): - return str(self.varlist) - def get_kwlist(self): - ret = ' static char *kwlist[] = { %s };\n' % \ - string.join(self.kwlist + [ 'NULL' ], ', ') - if not self.get_varlist(): - ret = ret + '\n' - return ret - - def add_parselist(self, codes, parseargs, keywords): - self.parsestr = self.parsestr + codes - for arg in parseargs: - self.parselist.append(arg) - for kw in keywords: - if keyword.iskeyword(kw): - kw = kw + '_' - self.kwlist.append('"%s"' % kw) - -class ArgType: - def write_param(self, ptype, pname, pdflt, pnull, info): - """Add code to the WrapperInfo instance to handle - parameter.""" - raise RuntimeError("write_param not implemented for %s" - % self.__class__.__name__) - def write_return(self, ptype, ownsreturn, info): - """Adds a variable named ret of the return type to - info.varlist, and add any required code to info.codeafter to - convert the return value to a python object.""" - raise RuntimeError("write_return not implemented for %s" - % self.__class__.__name__) - -class NoneArg(ArgType): - def write_return(self, ptype, ownsreturn, info): - info.codeafter.append(' Py_INCREF(Py_None);\n' + - ' return Py_None;') - -class StringArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt != None: - if pdflt != 'NULL': pdflt = '"' + pdflt + '"' - info.varlist.add('char', '*' + pname + ' = ' + pdflt) - else: - info.varlist.add('char', '*' + pname) - info.arglist.append(pname) - if pnull: - info.add_parselist('z', ['&' + pname], [pname]) - else: - info.add_parselist('s', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - if ownsreturn: - # have to free result ... - info.varlist.add('gchar', '*ret') - info.codeafter.append(' if (ret) {\n' + - ' PyObject *py_ret = PyString_FromString(ret);\n' + - ' g_free(ret);\n' + - ' return py_ret;\n' + - ' }\n' + - ' Py_INCREF(Py_None);\n' + - ' return Py_None;') - else: - info.varlist.add('const gchar', '*ret') - info.codeafter.append(' if (ret)\n' + - ' return PyString_FromString(ret);\n'+ - ' Py_INCREF(Py_None);\n' + - ' return Py_None;') - -class UCharArg(ArgType): - # allows strings with embedded NULLs. - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('guchar', '*' + pname + ' = "' + pdflt + '"') - else: - info.varlist.add('guchar', '*' + pname) - if py_ssize_t_clean: - info.varlist.add('Py_ssize_t', pname + '_len') - else: - info.varlist.add('int', pname + '_len') - info.arglist.append(pname) - if pnull: - info.add_parselist('z#', ['&' + pname, '&' + pname + '_len'], - [pname]) - else: - info.add_parselist('s#', ['&' + pname, '&' + pname + '_len'], - [pname]) - -class CharArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('char', pname + " = '" + pdflt + "'") - else: - info.varlist.add('char', pname) - info.arglist.append(pname) - info.add_parselist('c', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('gchar', 'ret') - info.codeafter.append(' return PyString_FromStringAndSize(&ret, 1);') -class GUniCharArg(ArgType): - ret_tmpl = ('#if !defined(Py_UNICODE_SIZE) || Py_UNICODE_SIZE == 2\n' - ' if (ret > 0xffff) {\n' - ' PyErr_SetString(PyExc_RuntimeError, "returned character can not be represented in 16-bit unicode");\n' - ' return NULL;\n' - ' }\n' - '#endif\n' - ' py_ret = (Py_UNICODE)ret;\n' - ' return PyUnicode_FromUnicode(&py_ret, 1);\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('gunichar', pname + " = '" + pdflt + "'") - else: - info.varlist.add('gunichar', pname) - info.arglist.append(pname) - info.add_parselist('O&', ['pyg_pyobj_to_unichar_conv', '&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('gunichar', 'ret') - info.varlist.add('Py_UNICODE', 'py_ret') - info.codeafter.append(self.ret_tmpl) - - -class IntArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('int', pname + ' = ' + pdflt) - else: - info.varlist.add('int', pname) - info.arglist.append(pname) - info.add_parselist('i', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('int', 'ret') - info.codeafter.append(' return PyInt_FromLong(ret);') - -class UIntArg(ArgType): - dflt = (' if (py_%(name)s) {\n' - ' if (PyLong_Check(py_%(name)s))\n' - ' %(name)s = PyLong_AsUnsignedLong(py_%(name)s);\n' - ' else if (PyInt_Check(py_%(name)s))\n' - ' %(name)s = PyInt_AsLong(py_%(name)s);\n' - ' else\n' - ' PyErr_SetString(PyExc_TypeError, "Parameter \'%(name)s\' must be an int or a long");\n' - ' if (PyErr_Occurred())\n' - ' return NULL;\n' - ' }\n') - before = (' if (PyLong_Check(py_%(name)s))\n' - ' %(name)s = PyLong_AsUnsignedLong(py_%(name)s);\n' - ' else if (PyInt_Check(py_%(name)s))\n' - ' %(name)s = PyInt_AsLong(py_%(name)s);\n' - ' else\n' - ' PyErr_SetString(PyExc_TypeError, "Parameter \'%(name)s\' must be an int or a long");\n' - ' if (PyErr_Occurred())\n' - ' return NULL;\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - if not pdflt: - pdflt = '0'; - - info.varlist.add(ptype, pname + ' = ' + pdflt) - info.codebefore.append(self.dflt % {'name':pname}) - info.varlist.add('PyObject', "*py_" + pname + ' = NULL') - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype, 'ret') - info.codeafter.append(' return PyLong_FromUnsignedLong(ret);') - -class SizeArg(ArgType): - - if struct.calcsize('P') <= struct.calcsize('l'): - llp64 = True - else: - llp64 = False - - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add(ptype, pname + ' = ' + pdflt) - else: - info.varlist.add(ptype, pname) - info.arglist.append(pname) - if self.llp64: - info.add_parselist('k', ['&' + pname], [pname]) - else: - info.add_parselist('K', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype, 'ret') - if self.llp64: - info.codeafter.append(' return PyLong_FromUnsignedLongLong(ret);\n') - else: - info.codeafter.append(' return PyLong_FromUnsignedLong(ret);\n') - -class SSizeArg(ArgType): - - if struct.calcsize('P') <= struct.calcsize('l'): - llp64 = True - else: - llp64 = False - - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add(ptype, pname + ' = ' + pdflt) - else: - info.varlist.add(ptype, pname) - info.arglist.append(pname) - if self.llp64: - info.add_parselist('l', ['&' + pname], [pname]) - else: - info.add_parselist('L', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype, 'ret') - if self.llp64: - info.codeafter.append(' return PyLong_FromLongLong(ret);\n') - else: - info.codeafter.append(' return PyLong_FromLong(ret);\n') - -class LongArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add(ptype, pname + ' = ' + pdflt) - else: - info.varlist.add(ptype, pname) - info.arglist.append(pname) - info.add_parselist('l', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype, 'ret') - info.codeafter.append(' return PyInt_FromLong(ret);\n') - -class BoolArg(IntArg): - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('int', 'ret') - info.codeafter.append(' return PyBool_FromLong(ret);\n') - -class TimeTArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('time_t', pname + ' = ' + pdflt) - else: - info.varlist.add('time_t', pname) - info.arglist.append(pname) - info.add_parselist('i', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('time_t', 'ret') - info.codeafter.append(' return PyInt_FromLong(ret);') - -class ULongArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('unsigned long', pname + ' = ' + pdflt) - else: - info.varlist.add('unsigned long', pname) - info.arglist.append(pname) - info.add_parselist('k', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype, 'ret') - info.codeafter.append(' return PyLong_FromUnsignedLong(ret);\n') - -class UInt32Arg(ULongArg): - def write_param(self, ptype, pname, pdflt, pnull, info): - ULongArg.write_param(self, ptype, pname, pdflt, pnull, info) - ## if sizeof(unsigned long) > sizeof(unsigned int), we need to - ## check the value is within guint32 range - if struct.calcsize('L') > struct.calcsize('I'): - info.codebefore.append(( - ' if (%(pname)s > G_MAXUINT32) {\n' - ' PyErr_SetString(PyExc_ValueError,\n' - ' "Value out of range in conversion of"\n' - ' " %(pname)s parameter to unsigned 32 bit integer");\n' - ' return NULL;\n' - ' }\n') % vars()) - -class Int64Arg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('gint64', pname + ' = ' + pdflt) - else: - info.varlist.add('gint64', pname) - info.arglist.append(pname) - info.add_parselist('L', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('gint64', 'ret') - info.codeafter.append(' return PyLong_FromLongLong(ret);') - -class UInt64Arg(ArgType): - dflt = ' if (py_%(name)s)\n' \ - ' %(name)s = PyLong_AsUnsignedLongLong(py_%(name)s);\n' - before = ' %(name)s = PyLong_AsUnsignedLongLong(py_%(name)s);\n' - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('guint64', pname + ' = ' + pdflt) - info.codebefore.append(self.dflt % {'name':pname}) - else: - info.varlist.add('guint64', pname) - info.codebefore.append(self.before % {'name':pname}) - info.varlist.add('PyObject', "*py_" + pname + ' = NULL') - info.arglist.append(pname) - info.add_parselist('O!', ['&PyLong_Type', '&py_' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('guint64', 'ret') - info.codeafter.append(' return PyLong_FromUnsignedLongLong(ret);') - - -class DoubleArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('double', pname + ' = ' + pdflt) - else: - info.varlist.add('double', pname) - info.arglist.append(pname) - info.add_parselist('d', ['&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('double', 'ret') - info.codeafter.append(' return PyFloat_FromDouble(ret);') - -class FileArg(ArgType): - nulldflt = (' if (py_%(name)s == Py_None)\n' - ' %(name)s = NULL;\n' - ' else if (py_%(name)s && PyFile_Check(py_%(name)s)\n' - ' %s = PyFile_AsFile(py_%(name)s);\n' - ' else if (py_%(name)s) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a file object or None");\n' - ' return NULL;\n' - ' }') - null = (' if (py_%(name)s && PyFile_Check(py_%(name)s)\n' - ' %(name)s = PyFile_AsFile(py_%(name)s);\n' - ' else if (py_%(name)s != Py_None) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a file object or None");\n' - ' return NULL;\n' - ' }\n') - dflt = (' if (py_%(name)s)\n' - ' %(name)s = PyFile_AsFile(py_%(name)s);\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - if pdflt: - info.varlist.add('FILE', '*' + pname + ' = ' + pdflt) - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.nulldflt % {'name':pname}) - else: - info.varlist.add('FILE', '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname) - info.codebefore.append(self.null & {'name':pname}) - info.arglist.appned(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - else: - if pdflt: - info.varlist.add('FILE', '*' + pname + ' = ' + pdflt) - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.dflt % {'name':pname}) - info.arglist.append(pname) - else: - info.varlist.add('PyObject', '*' + pname) - info.arglist.append('PyFile_AsFile(' + pname + ')') - info.add_parselist('O!', ['&PyFile_Type', '&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('FILE', '*ret') - info.codeafter.append(' if (ret)\n' + - ' return PyFile_FromFile(ret, "", "", fclose);\n' + - ' Py_INCREF(Py_None);\n' + - ' return Py_None;') - -class EnumArg(ArgType): - enum = (' if (pyg_enum_get_value(%(typecode)s, py_%(name)s, (gpointer)&%(name)s))\n' - ' return NULL;\n') - def __init__(self, enumname, typecode): - self.enumname = enumname - self.typecode = typecode - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add(self.enumname, pname + ' = ' + pdflt) - else: - info.varlist.add(self.enumname, pname) - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.enum % { 'typecode': self.typecode, - 'name': pname}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]); - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('gint', 'ret') - info.codeafter.append(' return pyg_enum_from_gtype(%s, ret);' % self.typecode) - -class FlagsArg(ArgType): - flag = (' if (%(default)spyg_flags_get_value(%(typecode)s, py_%(name)s, (gpointer)&%(name)s))\n' - ' return NULL;\n') - def __init__(self, flagname, typecode): - self.flagname = flagname - self.typecode = typecode - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add(self.flagname, pname + ' = ' + pdflt) - default = "py_%s && " % (pname,) - else: - info.varlist.add(self.flagname, pname) - default = "" - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.flag % {'default':default, - 'typecode':self.typecode, - 'name':pname}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('guint', 'ret') - info.codeafter.append(' return pyg_flags_from_gtype(%s, ret);' % self.typecode) - -class ObjectArg(ArgType): - # should change these checks to more typesafe versions that check - # a little further down in the class heirachy. - nulldflt = (' if ((PyObject *)py_%(name)s == Py_None)\n' - ' %(name)s = NULL;\n' - ' else if (py_%(name)s && pygobject_check(py_%(name)s, &Py%(type)s_Type))\n' - ' %(name)s = %(cast)s(py_%(name)s->obj);\n' - ' else if (py_%(name)s) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(type)s or None");\n' - ' return NULL;\n' - ' }\n') - null = (' if (py_%(name)s && pygobject_check(py_%(name)s, &Py%(type)s_Type))\n' - ' %(name)s = %(cast)s(py_%(name)s->obj);\n' - ' else if ((PyObject *)py_%(name)s != Py_None) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(type)s or None");\n' - ' return NULL;\n' - ' }\n') - dflt = ' if (py_%(name)s)\n' \ - ' %(name)s = %(cast)s(py_%(name)s->obj);\n' - def __init__(self, objname, parent, typecode): - self.objname = objname - self.cast = string.replace(typecode, '_TYPE_', '_', 1) - self.parent = parent - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - if pdflt: - info.varlist.add(self.objname, '*' + pname + ' = ' + pdflt) - info.varlist.add('PyGObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.nulldflt % {'name':pname, - 'cast':self.cast, - 'type':self.objname}) - else: - info.varlist.add(self.objname, '*' + pname + ' = NULL') - info.varlist.add('PyGObject', '*py_' + pname) - info.codebefore.append(self.null % {'name':pname, - 'cast':self.cast, - 'type':self.objname}) - if ptype.endswith('*'): - typename = ptype[:-1] - try: - const, typename = typename.split('const-') - except ValueError: - const = '' - if typename != ptype: - info.arglist.append('(%s *) %s' % (ptype[:-1], pname)) - else: - info.arglist.append(pname) - - info.add_parselist('O', ['&py_' + pname], [pname]) - else: - if pdflt: - info.varlist.add(self.objname, '*' + pname + ' = ' + pdflt) - info.varlist.add('PyGObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.dflt % {'name':pname, - 'cast':self.cast}) - info.arglist.append(pname) - info.add_parselist('O!', ['&Py%s_Type' % self.objname, - '&py_' + pname], [pname]) - else: - info.varlist.add('PyGObject', '*' + pname) - info.arglist.append('%s(%s->obj)' % (self.cast, pname)) - info.add_parselist('O!', ['&Py%s_Type' % self.objname, - '&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - if ptype.endswith('*'): - typename = ptype[:-1] - try: - const, typename = typename.split('const-') - except ValueError: - const = '' - info.varlist.add(typename, '*ret') - if ownsreturn: - info.varlist.add('PyObject', '*py_ret') - info.codeafter.append(' py_ret = pygobject_new((GObject *)ret);\n' - ' if (ret != NULL)\n' - ' g_object_unref(ret);\n' - ' return py_ret;') - else: - info.codeafter.append(' /* pygobject_new handles NULL checking */\n' + - ' return pygobject_new((GObject *)ret);') - -class BoxedArg(ArgType): - # haven't done support for default args. Is it needed? - check = (' if (pyg_boxed_check(py_%(name)s, %(typecode)s))\n' - ' %(name)s = pyg_boxed_get(py_%(name)s, %(typename)s);\n' - ' else {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(typename)s");\n' - ' return NULL;\n' - ' }\n') - null = (' if (pyg_boxed_check(py_%(name)s, %(typecode)s))\n' - ' %(name)s = pyg_boxed_get(py_%(name)s, %(typename)s);\n' - ' else if (py_%(name)s != Py_None) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(typename)s or None");\n' - ' return NULL;\n' - ' }\n') - def __init__(self, ptype, typecode): - self.typename = ptype - self.typecode = typecode - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - info.varlist.add(self.typename, '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname + ' = Py_None') - info.codebefore.append(self.null % {'name': pname, - 'typename': self.typename, - 'typecode': self.typecode}) - else: - info.varlist.add(self.typename, '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname) - info.codebefore.append(self.check % {'name': pname, - 'typename': self.typename, - 'typecode': self.typecode}) - if ptype[-1] == '*': - typename = ptype[:-1] - if typename[:6] == 'const-': typename = typename[6:] - if typename != self.typename: - info.arglist.append('(%s *)%s' % (ptype[:-1], pname)) - else: - info.arglist.append(pname) - else: - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - ret_tmpl = ' /* pyg_boxed_new handles NULL checking */\n' \ - ' return pyg_boxed_new(%(typecode)s, %(ret)s, %(copy)s, TRUE);' - def write_return(self, ptype, ownsreturn, info): - if ptype[-1] == '*': - decl_type = self.typename - ret = 'ret' - if ptype[:6] == 'const-': - decl_type = 'const ' + self.typename - ret = '(%s*) ret' % (self.typename,) - info.varlist.add(decl_type, '*ret') - else: - info.varlist.add(self.typename, 'ret') - ret = '&ret' - ownsreturn = 0 # of course it can't own a ref to a local var ... - info.codeafter.append(self.ret_tmpl % - { 'typecode': self.typecode, - 'ret': ret, - 'copy': ownsreturn and 'FALSE' or 'TRUE'}) - -class CustomBoxedArg(ArgType): - # haven't done support for default args. Is it needed? - null = (' if (%(check)s(py_%(name)s))\n' - ' %(name)s = %(get)s(py_%(name)s);\n' - ' else if (py_%(name)s != Py_None) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(type)s or None");\n' - ' return NULL;\n' - ' }\n') - def __init__(self, ptype, pytype, getter, new): - self.pytype = pytype - self.getter = getter - self.checker = 'Py' + ptype + '_Check' - self.new = new - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - info.varlist.add(ptype[:-1], '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname + ' = Py_None') - info.codebefore.append(self.null % {'name': pname, - 'get': self.getter, - 'check': self.checker, - 'type': ptype[:-1]}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - else: - info.varlist.add('PyObject', '*' + pname) - info.arglist.append(self.getter + '(' + pname + ')') - info.add_parselist('O!', ['&' + self.pytype, '&' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add(ptype[:-1], '*ret') - info.codeafter.append(' if (ret)\n' + - ' return ' + self.new + '(ret);\n' + - ' Py_INCREF(Py_None);\n' + - ' return Py_None;') - -class PointerArg(ArgType): - # haven't done support for default args. Is it needed? - check = (' if (pyg_pointer_check(py_%(name)s, %(typecode)s))\n' - ' %(name)s = pyg_pointer_get(py_%(name)s, %(typename)s);\n' - ' else {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(typename)s");\n' - ' return NULL;\n' - ' }\n') - null = (' if (pyg_pointer_check(py_%(name)s, %(typecode)s))\n' - ' %(name)s = pyg_pointer_get(py_%(name)s, %(typename)s);\n' - ' else if (py_%(name)s != Py_None) {\n' - ' PyErr_SetString(PyExc_TypeError, "%(name)s should be a %(typename)s or None");\n' - ' return NULL;\n' - ' }\n') - def __init__(self, ptype, typecode): - self.typename = ptype - self.typecode = typecode - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - info.varlist.add(self.typename, '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname + ' = Py_None') - info.codebefore.append(self.null % {'name': pname, - 'typename': self.typename, - 'typecode': self.typecode}) - else: - info.varlist.add(self.typename, '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname) - info.codebefore.append(self.check % {'name': pname, - 'typename': self.typename, - 'typecode': self.typecode}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - if ptype[-1] == '*': - info.varlist.add(self.typename, '*ret') - info.codeafter.append(' /* pyg_pointer_new handles NULL checking */\n' + - ' return pyg_pointer_new(' + self.typecode + ', ret);') - else: - info.varlist.add(self.typename, 'ret') - info.codeafter.append(' /* pyg_pointer_new handles NULL checking */\n' + - ' return pyg_pointer_new(' + self.typecode + ', &ret);') - -class AtomArg(IntArg): - dflt = ' if (py_%(name)s) {\n' \ - ' %(name)s = pygdk_atom_from_pyobject(py_%(name)s);\n' \ - ' if (PyErr_Occurred())\n' \ - ' return NULL;\n' \ - ' }\n' - atom = (' %(name)s = pygdk_atom_from_pyobject(py_%(name)s);\n' - ' if (PyErr_Occurred())\n' - ' return NULL;\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - if pdflt: - info.varlist.add('GdkAtom', pname + ' = ' + pdflt) - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.dflt % {'name': pname}) - else: - info.varlist.add('GdkAtom', pname) - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.atom % {'name': pname}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('GdkAtom', 'ret') - info.varlist.add('PyObject *', 'py_ret') - info.varlist.add('gchar *', 'name') - info.codeafter.append(' name = gdk_atom_name(ret);\n' - ' py_ret = PyString_FromString(name);\n' - ' g_free(name);\n' - ' return py_ret;') - -class GTypeArg(ArgType): - gtype = (' if ((%(name)s = pyg_type_from_object(py_%(name)s)) == 0)\n' - ' return NULL;\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('GType', pname) - info.varlist.add('PyObject', '*py_' + pname + ' = NULL') - info.codebefore.append(self.gtype % {'name': pname}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('GType', 'ret') - info.codeafter.append(' return pyg_type_wrapper_new(ret);') - -# simple GError handler. -class GErrorArg(ArgType): - handleerror = (' if (pyg_error_check(&%(name)s))\n' - ' return NULL;\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('GError', '*' + pname + ' = NULL') - info.arglist.append('&' + pname) - info.codeafter.append(self.handleerror % { 'name': pname }) - -class GtkTreePathArg(ArgType): - # haven't done support for default args. Is it needed? - normal = (' %(name)s = pygtk_tree_path_from_pyobject(py_%(name)s);\n' - ' if (!%(name)s) {\n' - ' PyErr_SetString(PyExc_TypeError, "could not convert %(name)s to a GtkTreePath");\n' - ' return NULL;\n' - ' }\n') - null = (' if (py_%(name)s != Py_None) {\n' - ' %(name)s = pygtk_tree_path_from_pyobject(py_%(name)s);\n' - ' if (!%(name)s) {\n' - ' PyErr_SetString(PyExc_TypeError, "could not convert %(name)s to a GtkTreePath");\n' - ' return NULL;\n' - ' }\n' - ' }\n') - freepath = (' if (%(name)s)\n' - ' gtk_tree_path_free(%(name)s);\n') - def __init__(self): - pass - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - info.varlist.add('GtkTreePath', '*' + pname + ' = NULL') - info.varlist.add('PyObject', '*py_' + pname + ' = Py_None') - info.codebefore.append(self.null % {'name': pname}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - else: - info.varlist.add('GtkTreePath', '*' + pname) - info.varlist.add('PyObject', '*py_' + pname) - info.codebefore.append(self.normal % {'name': pname}) - info.arglist.append(pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - info.codeafter.append(self.freepath % {'name': pname}) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('GtkTreePath', '*ret') - if ownsreturn: - info.codeafter.append(' if (ret) {\n' - ' PyObject *py_ret = pygtk_tree_path_to_pyobject(ret);\n' - ' gtk_tree_path_free(ret);\n' - ' return py_ret;\n' - ' }\n' - ' Py_INCREF(Py_None);\n' - ' return Py_None;') - else: - info.codeafter.append(' if (ret) {\n' - ' PyObject *py_ret = pygtk_tree_path_to_pyobject(ret);\n' - ' return py_ret;\n' - ' }\n' - ' Py_INCREF(Py_None);\n' - ' return Py_None;') - -class GdkRectanglePtrArg(ArgType): - normal = (' if (!pygdk_rectangle_from_pyobject(py_%(name)s, &%(name)s))\n' - ' return NULL;\n') - null = (' if (py_%(name)s == Py_None)\n' - ' %(name)s = NULL;\n' - ' else if (pygdk_rectangle_from_pyobject(py_%(name)s, &%(name)s_rect))\n' - ' %(name)s = &%(name)s_rect;\n' - ' else\n' - ' return NULL;\n') - def write_param(self, ptype, pname, pdflt, pnull, info): - if pnull: - info.varlist.add('GdkRectangle', pname + '_rect = { 0, 0, 0, 0 }') - info.varlist.add('GdkRectangle', '*' + pname) - info.varlist.add('PyObject', '*py_' + pname + ' = Py_None') - info.add_parselist('O', ['&py_' + pname], [pname]) - info.arglist.append(pname) - info.codebefore.append(self.null % {'name': pname}) - else: - info.varlist.add('GdkRectangle', pname + ' = { 0, 0, 0, 0 }') - info.varlist.add('PyObject', '*py_' + pname) - info.add_parselist('O', ['&py_' + pname], [pname]) - info.arglist.append('&' + pname) - info.codebefore.append(self.normal % {'name': pname}) - -class GdkRectangleArg(ArgType): - def write_return(self, ptype, ownsreturn, info): - info.varlist.add('GdkRectangle', 'ret') - info.codeafter.append(' return pyg_boxed_new(GDK_TYPE_RECTANGLE, &ret, TRUE, TRUE);') - -class PyObjectArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('PyObject', '*' + pname) - info.add_parselist('O', ['&' + pname], [pname]) - info.arglist.append(pname) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add("PyObject", "*ret") - if ownsreturn: - info.codeafter.append(' if (ret) {\n' - ' return ret;\n' - ' }\n' - ' Py_INCREF(Py_None);\n' - ' return Py_None;') - else: - info.codeafter.append(' if (!ret) ret = Py_None;\n' - ' Py_INCREF(ret);\n' - ' return ret;') - -class CairoArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('PycairoContext', '*' + pname) - info.add_parselist('O!', ['&PycairoContext_Type', '&' + pname], [pname]) - info.arglist.append('%s->ctx' % pname) - def write_return(self, ptype, ownsreturn, info): - info.varlist.add("cairo_t", "*ret") - if ownsreturn: - info.codeafter.append(' return PycairoContext_FromContext(ret, NULL, NULL);') - else: - info.codeafter.append(' cairo_reference(ret);\n' - ' return PycairoContext_FromContext(ret, NULL, NULL);') - -class GstElementArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('GstElement', '*' + pname) - info.add_parselist('O!', ['&PyGstElement_Type', '&' + pname], [pname]) - info.arglist.append('%s' % pname) - - def write_return(self, ptype, ownsreturn, info): - info.varlist.add("GstElement", "*ret") - if ownsreturn: - info.varlist.add('PyObject', '*py_ret') - info.codeafter.append(' py_ret = pygobject_new((GObject *)ret);\n' - ' if (ret != NULL)\n' - ' g_object_unref(ret);\n' - ' return py_ret;') - else: - info.codeafter.append(' /* pygobject_new handles NULL checking */\n' + - ' return pygobject_new((GObject *)ret);') - -class GstPadArg(ArgType): - def write_param(self, ptype, pname, pdflt, pnull, info): - info.varlist.add('GstPad', '*' + pname) - info.add_parselist('O!', ['&PyGstPad_Type', '&' + pname], [pname]) - info.arglist.append('%s' % pname) - - def write_return(self, ptype, ownsreturn, info): - info.varlist.add("GstPad", "*ret") - if ownsreturn: - info.varlist.add('PyObject', '*py_ret') - info.codeafter.append(' py_ret = pygobject_new((GObject *)ret);\n' - ' if (ret != NULL)\n' - ' g_object_unref(ret);\n' - ' return py_ret;') - else: - info.codeafter.append(' /* pygobject_new handles NULL checking */\n' + - ' return pygobject_new((GObject *)ret);') - -class ArgMatcher: - def __init__(self): - self.argtypes = {} - self.reverse_argtypes = {} - self.reverse_rettypes = {} - - def register(self, ptype, handler, overwrite=False): - if not overwrite and ptype in self.argtypes: - return - self.argtypes[ptype] = handler - def register_reverse(self, ptype, handler): - self.reverse_argtypes[ptype] = handler - def register_reverse_ret(self, ptype, handler): - self.reverse_rettypes[ptype] = handler - - def register_enum(self, ptype, typecode): - if typecode is None: - self.register(ptype, IntArg()) - else: - self.register(ptype, EnumArg(ptype, typecode)) - def register_flag(self, ptype, typecode): - if typecode is None: - self.register(ptype, IntArg()) - else: - self.register(ptype, FlagsArg(ptype, typecode)) - def register_object(self, ptype, parent, typecode): - oa = ObjectArg(ptype, parent, typecode) - self.register(ptype, oa) # in case I forget the * in the .defs - self.register(ptype+'*', oa) - self.register('const-'+ptype+'*', oa) - if ptype == 'GdkPixmap': - # hack to handle GdkBitmap synonym. - self.register('GdkBitmap', oa) - self.register('GdkBitmap*', oa) - def register_boxed(self, ptype, typecode): - if self.argtypes.has_key(ptype): return - arg = BoxedArg(ptype, typecode) - self.register(ptype, arg) - self.register(ptype+'*', arg) - self.register('const-'+ptype+'*', arg) - def register_custom_boxed(self, ptype, pytype, getter, new): - arg = CustomBoxedArg(ptype, pytype, getter, new) - self.register(ptype+'*', arg) - self.register('const-'+ptype+'*', arg) - def register_pointer(self, ptype, typecode): - arg = PointerArg(ptype, typecode) - self.register(ptype, arg) - self.register(ptype+'*', arg) - self.register('const-'+ptype+'*', arg) - - def get(self, ptype): - try: - return self.argtypes[ptype] - except KeyError: - if ptype[:8] == 'GdkEvent' and ptype[-1] == '*': - return self.argtypes['GdkEvent*'] - raise ArgTypeNotFoundError("No ArgType for %s" % (ptype,)) - def _get_reverse_common(self, ptype, registry): - props = dict(c_type=ptype) - try: - return registry[ptype], props - except KeyError: - try: - handler = self.argtypes[ptype] - except KeyError: - if ptype.startswith('GdkEvent') and ptype.endswith('*'): - handler = self.argtypes['GdkEvent*'] - else: - raise ArgTypeNotFoundError("No ArgType for %s" % (ptype,)) - if isinstance(handler, ObjectArg): - return registry['GObject*'], props - elif isinstance(handler, EnumArg): - props['typecode'] = handler.typecode - props['enumname'] = handler.enumname - return registry['GEnum'], props - elif isinstance(handler, FlagsArg): - props['typecode'] = handler.typecode - props['flagname'] = handler.flagname - return registry['GFlags'], props - elif isinstance(handler, BoxedArg): - props['typecode'] = handler.typecode - props['typename'] = handler.typename - return registry['GBoxed'], props - else: - raise ArgTypeNotFoundError("No ArgType for %s" % (ptype,)) - - def get_reverse(self, ptype): - return self._get_reverse_common(ptype, self.reverse_argtypes) - - def get_reverse_ret(self, ptype): - ret, props = self._get_reverse_common(ptype, self.reverse_rettypes) - if hasattr(ptype, 'optional') and ptype.optional: - if ret.supports_optional: - props['optional'] = True - else: - raise ArgTypeNotFoundError("Unsupported 'optional' for %s" - % (ptype,)) - return ret, props - - def object_is_a(self, otype, parent): - if otype == None: return 0 - if otype == parent: return 1 - if not self.argtypes.has_key(otype): return 0 - return self.object_is_a(self.get(otype).parent, parent) - -matcher = ArgMatcher() - -arg = NoneArg() -matcher.register(None, arg) -matcher.register('none', arg) - -arg = StringArg() -matcher.register('char*', arg) -matcher.register('gchar*', arg) -matcher.register('const-char*', arg) -matcher.register('char-const*', arg) -matcher.register('const-gchar*', arg) -matcher.register('gchar-const*', arg) -matcher.register('string', arg) -matcher.register('static_string', arg) - -arg = UCharArg() -matcher.register('unsigned-char*', arg) -matcher.register('const-guchar*', arg) -matcher.register('const-guint8*', arg) -matcher.register('guchar*', arg) - -arg = CharArg() -matcher.register('char', arg) -matcher.register('gchar', arg) -matcher.register('guchar', arg) - -arg = GUniCharArg() -matcher.register('gunichar', arg) - -arg = IntArg() -matcher.register('int', arg) -matcher.register('gint', arg) -matcher.register('short', arg) -matcher.register('gshort', arg) -matcher.register('gushort', arg) -matcher.register('gsize', SizeArg()) -matcher.register('gssize', SSizeArg()) -matcher.register('guint8', arg) -matcher.register('gint8', arg) -matcher.register('guint16', arg) -matcher.register('gint16', arg) -matcher.register('gint32', arg) -matcher.register('GTime', arg) -matcher.register('GSeekType', arg) # Hack, but we have no python wrapper - -arg = LongArg() -matcher.register('long', arg) -matcher.register('glong', arg) - -arg = UIntArg() -matcher.register('guint', arg) - -arg = BoolArg() -matcher.register('gboolean', arg) - -arg = TimeTArg() -matcher.register('time_t', arg) - -matcher.register('guint32', UInt32Arg()) - -arg = ULongArg() -matcher.register('gulong', arg) - -arg = Int64Arg() -matcher.register('gint64', arg) -matcher.register('long-long', arg) -matcher.register('goffset', arg) - -arg = UInt64Arg() -matcher.register('guint64', arg) -matcher.register('unsigned-long-long', arg) - -arg = DoubleArg() -matcher.register('double', arg) -matcher.register('gdouble', arg) -matcher.register('float', arg) -matcher.register('gfloat', arg) - -arg = FileArg() -matcher.register('FILE*', arg) - -# enums, flags, objects - -matcher.register('GdkAtom', AtomArg()) - -matcher.register('GType', GTypeArg()) -matcher.register('GtkType', GTypeArg()) - -matcher.register('GError**', GErrorArg()) -matcher.register('GtkTreePath*', GtkTreePathArg()) -matcher.register('GdkRectangle*', GdkRectanglePtrArg()) -matcher.register('GtkAllocation*', GdkRectanglePtrArg()) -matcher.register('GdkRectangle', GdkRectangleArg()) -matcher.register('PyObject*', PyObjectArg()) -matcher.register('GstElement*', GstElementArg()) -matcher.register('GstPad*', GstPadArg()) - -matcher.register('GdkNativeWindow', ULongArg()) - -matcher.register_object('GObject', None, 'G_TYPE_OBJECT') - -del arg - -matcher.register('cairo_t*', CairoArg()) -matcher.register_boxed("GClosure", "G_TYPE_CLOSURE") diff --git a/bindings/python/codegen/code-coverage.py b/bindings/python/codegen/code-coverage.py deleted file mode 100755 index 1dc54c305f..0000000000 --- a/bindings/python/codegen/code-coverage.py +++ /dev/null @@ -1,44 +0,0 @@ -#! /usr/bin/env python - -from __future__ import generators -import sys, os - -def read_symbols(file, type=None, dynamic=0): - if dynamic: - cmd = 'nm -D %s' % file - else: - cmd = 'nm %s' % file - for line in os.popen(cmd, 'r'): - if line[0] != ' ': # has an address as first bit of line - while line[0] != ' ': - line = line[1:] - while line[0] == ' ': - line = line[1:] - # we should be up to "type symbolname" now - sym_type = line[0] - symbol = line[1:].strip() - - if not type or type == sym_type: - yield symbol - -def main(): - if len(sys.argv) != 3: - sys.stderr.write('usage: coverage-check library.so wrapper.so\n') - sys.exit(1) - library = sys.argv[1] - wrapper = sys.argv[2] - - # first create a dict with all referenced symbols in the wrapper - # should really be a set, but a dict will do ... - wrapper_symbols = {} - for symbol in read_symbols(wrapper, type='U', dynamic=1): - wrapper_symbols[symbol] = 1 - - # now go through the library looking for matches on the defined symbols: - for symbol in read_symbols(library, type='T', dynamic=1): - if symbol[0] == '_': continue - if symbol not in wrapper_symbols: - print symbol - -if __name__ == '__main__': - main() diff --git a/bindings/python/codegen/codegen.py b/bindings/python/codegen/codegen.py deleted file mode 100755 index 008f01cc1f..0000000000 --- a/bindings/python/codegen/codegen.py +++ /dev/null @@ -1,1722 +0,0 @@ -#! /usr/bin/env python - -import getopt -import keyword -import os -import string -import sys - -import argtypes -import definitions -import defsparser -import override -import reversewrapper -import warnings - -class Coverage(object): - def __init__(self, name): - self.name = name - self.wrapped = 0 - self.not_wrapped = 0 - - def declare_wrapped(self): - self.wrapped += 1 - - def declare_not_wrapped(self): - self.not_wrapped += 1 - - def printstats(self): - total = self.wrapped + self.not_wrapped - fd = sys.stderr - if total: - fd.write("***INFO*** The coverage of %s is %.2f%% (%i/%i)\n" % - (self.name, - float(self.wrapped*100)/total, - self.wrapped, - total)) - else: - fd.write("***INFO*** There are no declared %s.\n" % self.name) - -functions_coverage = Coverage("global functions") -methods_coverage = Coverage("methods") -vproxies_coverage = Coverage("virtual proxies") -vaccessors_coverage = Coverage("virtual accessors") -iproxies_coverage = Coverage("interface proxies") - -def exc_info(): - warnings.warn("deprecated", DeprecationWarning, stacklevel=2) - #traceback.print_exc() - etype, value, tb = sys.exc_info() - ret = "" - try: - sval = str(value) - if etype == argtypes.ArgTypeError: - ret = "No ArgType for %s" % (sval,) - else: - ret = sval - finally: - del etype, value, tb - return ret - -def fixname(name): - if keyword.iskeyword(name): - return name + '_' - return name - -class FileOutput: - '''Simple wrapper for file object, that makes writing #line - statements easier.''' # " - def __init__(self, fp, filename=None): - self.fp = fp - self.lineno = 1 - if filename: - self.filename = filename - else: - self.filename = self.fp.name - # handle writing to the file, and keep track of the line number ... - def write(self, str): - self.fp.write(str) - self.lineno = self.lineno + string.count(str, '\n') - def writelines(self, sequence): - for line in sequence: - self.write(line) - def close(self): - self.fp.close() - def flush(self): - self.fp.flush() - - def setline(self, linenum, filename): - '''writes out a #line statement, for use by the C - preprocessor.''' # " - self.write('#line %d "%s"\n' % (linenum, filename)) - def resetline(self): - '''resets line numbering to the original file''' - self.setline(self.lineno + 1, self.filename) - -class Wrapper: - type_tmpl = ( - 'PyTypeObject G_GNUC_INTERNAL Py%(typename)s_Type = {\n' - ' PyObject_HEAD_INIT(NULL)\n' - ' 0, /* ob_size */\n' - ' "%(classname)s", /* tp_name */\n' - ' sizeof(%(tp_basicsize)s), /* tp_basicsize */\n' - ' 0, /* tp_itemsize */\n' - ' /* methods */\n' - ' (destructor)%(tp_dealloc)s, /* tp_dealloc */\n' - ' (printfunc)0, /* tp_print */\n' - ' (getattrfunc)%(tp_getattr)s, /* tp_getattr */\n' - ' (setattrfunc)%(tp_setattr)s, /* tp_setattr */\n' - ' (cmpfunc)%(tp_compare)s, /* tp_compare */\n' - ' (reprfunc)%(tp_repr)s, /* tp_repr */\n' - ' (PyNumberMethods*)%(tp_as_number)s, /* tp_as_number */\n' - ' (PySequenceMethods*)%(tp_as_sequence)s, /* tp_as_sequence */\n' - ' (PyMappingMethods*)%(tp_as_mapping)s, /* tp_as_mapping */\n' - ' (hashfunc)%(tp_hash)s, /* tp_hash */\n' - ' (ternaryfunc)%(tp_call)s, /* tp_call */\n' - ' (reprfunc)%(tp_str)s, /* tp_str */\n' - ' (getattrofunc)%(tp_getattro)s, /* tp_getattro */\n' - ' (setattrofunc)%(tp_setattro)s, /* tp_setattro */\n' - ' (PyBufferProcs*)%(tp_as_buffer)s, /* tp_as_buffer */\n' - ' %(tp_flags)s, /* tp_flags */\n' - ' %(tp_doc)s, /* Documentation string */\n' - ' (traverseproc)%(tp_traverse)s, /* tp_traverse */\n' - ' (inquiry)%(tp_clear)s, /* tp_clear */\n' - ' (richcmpfunc)%(tp_richcompare)s, /* tp_richcompare */\n' - ' %(tp_weaklistoffset)s, /* tp_weaklistoffset */\n' - ' (getiterfunc)%(tp_iter)s, /* tp_iter */\n' - ' (iternextfunc)%(tp_iternext)s, /* tp_iternext */\n' - ' (struct PyMethodDef*)%(tp_methods)s, /* tp_methods */\n' - ' (struct PyMemberDef*)0, /* tp_members */\n' - ' (struct PyGetSetDef*)%(tp_getset)s, /* tp_getset */\n' - ' NULL, /* tp_base */\n' - ' NULL, /* tp_dict */\n' - ' (descrgetfunc)%(tp_descr_get)s, /* tp_descr_get */\n' - ' (descrsetfunc)%(tp_descr_set)s, /* tp_descr_set */\n' - ' %(tp_dictoffset)s, /* tp_dictoffset */\n' - ' (initproc)%(tp_init)s, /* tp_init */\n' - ' (allocfunc)%(tp_alloc)s, /* tp_alloc */\n' - ' (newfunc)%(tp_new)s, /* tp_new */\n' - ' (freefunc)%(tp_free)s, /* tp_free */\n' - ' (inquiry)%(tp_is_gc)s /* tp_is_gc */\n' - '};\n\n' - ) - - slots_list = [ - 'tp_getattr', 'tp_setattr', 'tp_getattro', 'tp_setattro', - 'tp_compare', 'tp_repr', - 'tp_as_number', 'tp_as_sequence', 'tp_as_mapping', 'tp_hash', - 'tp_call', 'tp_str', 'tp_as_buffer', 'tp_richcompare', 'tp_iter', - 'tp_iternext', 'tp_descr_get', 'tp_descr_set', 'tp_init', - 'tp_alloc', 'tp_new', 'tp_free', 'tp_is_gc', - 'tp_traverse', 'tp_clear', 'tp_dealloc', 'tp_flags', 'tp_doc' - ] - - getter_tmpl = ( - 'static PyObject *\n' - '%(funcname)s(PyObject *self, void *closure)\n' - '{\n' - '%(varlist)s' - ' ret = %(field)s;\n' - '%(codeafter)s\n' - '}\n\n' - ) - - parse_tmpl = ( - ' if (!PyArg_ParseTupleAndKeywords(args, kwargs,' - '"%(typecodes)s:%(name)s"%(parselist)s))\n' - ' return %(errorreturn)s;\n' - ) - - deprecated_tmpl = ( - ' if (PyErr_Warn(PyExc_DeprecationWarning, ' - '"%(deprecationmsg)s") < 0)\n' - ' return %(errorreturn)s;\n' - ) - - methdef_tmpl = ( - ' { "%(name)s", (PyCFunction)%(cname)s, %(flags)s,\n' - ' %(docstring)s },\n' - ) - - noconstructor = ( - 'static int\n' - 'pygobject_no_constructor(PyObject *self, PyObject *args, ' - 'PyObject *kwargs)\n' - '{\n' - ' gchar buf[512];\n' - '\n' - ' g_snprintf(buf, sizeof(buf), "%s is an abstract widget", ' - 'self->ob_type->tp_name);\n' - ' PyErr_SetString(PyExc_NotImplementedError, buf);\n' - ' return -1;\n' - '}\n\n' - ) - - function_tmpl = ( - 'static PyObject *\n' - '_wrap_%(cname)s(PyObject *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' %(begin_allow_threads)s\n' - ' %(setreturn)s%(cname)s(%(arglist)s);\n' - ' %(end_allow_threads)s\n' - '%(codeafter)s\n' - '}\n\n' - ) - - virtual_accessor_tmpl = ( - 'static PyObject *\n' - '_wrap_%(cname)s(PyObject *cls%(extraparams)s)\n' - '{\n' - ' gpointer klass;\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' klass = g_type_class_ref(pyg_type_from_object(cls));\n' - ' if (%(class_cast_macro)s(klass)->%(virtual)s)\n' - ' %(setreturn)s%(class_cast_macro)s(klass)->' - '%(virtual)s(%(arglist)s);\n' - ' else {\n' - ' PyErr_SetString(PyExc_NotImplementedError, ' - '"virtual method %(name)s not implemented");\n' - ' g_type_class_unref(klass);\n' - ' return NULL;\n' - ' }\n' - ' g_type_class_unref(klass);\n' - '%(codeafter)s\n' - '}\n\n' - ) - - # template for method calls - constructor_tmpl = None - method_tmpl = None - - def __init__(self, parser, objinfo, overrides, fp=FileOutput(sys.stdout)): - self.parser = parser - self.objinfo = objinfo - self.overrides = overrides - self.fp = fp - - def get_lower_name(self): - return string.lower(string.replace(self.objinfo.typecode, - '_TYPE_', '_', 1)) - - def get_field_accessor(self, fieldname): - raise NotImplementedError - - def get_initial_class_substdict(self): return {} - - def get_initial_constructor_substdict(self, constructor): - return { 'name': '%s.__init__' % self.objinfo.py_name, - 'errorreturn': '-1' } - - def get_initial_method_substdict(self, method): - substdict = { 'name': '%s.%s' % (self.objinfo.py_name, method.name) } - if method.unblock_threads: - substdict['begin_allow_threads'] = 'pyg_begin_allow_threads;' - substdict['end_allow_threads'] = 'pyg_end_allow_threads;' - else: - substdict['begin_allow_threads'] = '' - substdict['end_allow_threads'] = '' - return substdict - - def write_class(self): - if self.overrides.is_type_ignored(self.objinfo.c_name): - return - self.fp.write('\n/* ----------- %s ----------- */\n\n' % - self.objinfo.c_name) - substdict = self.get_initial_class_substdict() - if not substdict.has_key('tp_flags'): - substdict['tp_flags'] = 'Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE' - substdict['typename'] = self.objinfo.c_name - if self.overrides.modulename: - substdict['classname'] = '%s.%s' % (self.overrides.modulename, - self.objinfo.name) - else: - substdict['classname'] = self.objinfo.name - substdict['tp_doc'] = self.objinfo.docstring - - # Maybe this could be done in a nicer way, but I'll leave it as it is - # for now: -- Johan - if not self.overrides.slot_is_overriden('%s.tp_init' % - self.objinfo.c_name): - substdict['tp_init'] = self.write_constructor() - substdict['tp_methods'] = self.write_methods() - substdict['tp_getset'] = self.write_getsets() - - # handle slots ... - for slot in self.slots_list: - - slotname = '%s.%s' % (self.objinfo.c_name, slot) - slotfunc = '_wrap_%s_%s' % (self.get_lower_name(), slot) - if slot[:6] == 'tp_as_': - slotfunc = '&' + slotfunc - if self.overrides.slot_is_overriden(slotname): - data = self.overrides.slot_override(slotname) - self.write_function(slotname, data) - substdict[slot] = slotfunc - else: - if not substdict.has_key(slot): - substdict[slot] = '0' - - self.fp.write(self.type_tmpl % substdict) - - self.write_virtuals() - - def write_function_wrapper(self, function_obj, template, - handle_return=0, is_method=0, kwargs_needed=0, - substdict=None): - '''This function is the guts of all functions that generate - wrappers for functions, methods and constructors.''' - if not substdict: substdict = {} - - info = argtypes.WrapperInfo() - - substdict.setdefault('errorreturn', 'NULL') - - # for methods, we want the leading comma - if is_method: - info.arglist.append('') - - if function_obj.varargs: - raise argtypes.ArgTypeNotFoundError("varargs functions not supported") - - for param in function_obj.params: - if param.pdflt != None and '|' not in info.parsestr: - info.add_parselist('|', [], []) - handler = argtypes.matcher.get(param.ptype) - handler.write_param(param.ptype, param.pname, param.pdflt, - param.pnull, info) - - substdict['setreturn'] = '' - if handle_return: - if function_obj.ret not in ('none', None): - substdict['setreturn'] = 'ret = ' - handler = argtypes.matcher.get(function_obj.ret) - handler.write_return(function_obj.ret, - function_obj.caller_owns_return, info) - - if function_obj.deprecated != None: - deprecated = self.deprecated_tmpl % { - 'deprecationmsg': function_obj.deprecated, - 'errorreturn': substdict['errorreturn'] } - else: - deprecated = '' - - # if name isn't set, set it to function_obj.name - substdict.setdefault('name', function_obj.name) - - if function_obj.unblock_threads: - substdict['begin_allow_threads'] = 'pyg_begin_allow_threads;' - substdict['end_allow_threads'] = 'pyg_end_allow_threads;' - else: - substdict['begin_allow_threads'] = '' - substdict['end_allow_threads'] = '' - - if self.objinfo: - substdict['typename'] = self.objinfo.c_name - substdict.setdefault('cname', function_obj.c_name) - substdict['varlist'] = info.get_varlist() - substdict['typecodes'] = info.parsestr - substdict['parselist'] = info.get_parselist() - substdict['arglist'] = info.get_arglist() - substdict['codebefore'] = deprecated + ( - string.replace(info.get_codebefore(), - 'return NULL', 'return ' + substdict['errorreturn']) - ) - substdict['codeafter'] = ( - string.replace(info.get_codeafter(), - 'return NULL', - 'return ' + substdict['errorreturn'])) - - if info.parsestr or kwargs_needed: - substdict['parseargs'] = self.parse_tmpl % substdict - substdict['extraparams'] = ', PyObject *args, PyObject *kwargs' - flags = 'METH_VARARGS|METH_KEYWORDS' - - # prepend the keyword list to the variable list - substdict['varlist'] = info.get_kwlist() + substdict['varlist'] - else: - substdict['parseargs'] = '' - substdict['extraparams'] = '' - flags = 'METH_NOARGS' - - return template % substdict, flags - - def write_constructor(self): - initfunc = '0' - constructor = self.parser.find_constructor(self.objinfo,self.overrides) - if not constructor: - return self.write_default_constructor() - - funcname = constructor.c_name - try: - if self.overrides.is_overriden(funcname): - data = self.overrides.override(funcname) - self.write_function(funcname, data) - self.objinfo.has_new_constructor_api = ( - self.objinfo.typecode in - self.overrides.newstyle_constructors) - else: - # ok, a hack to determine if we should use - # new-style constructores :P - property_based = getattr(self, - 'write_property_based_constructor', - None) - if property_based: - if (len(constructor.params) == 0 or - isinstance(constructor.params[0], - definitions.Property)): - # write_property_based_constructor is only - # implemented in GObjectWrapper - return self.write_property_based_constructor( - constructor) - else: - sys.stderr.write( - "Warning: generating old-style constructor for:" + - constructor.c_name + '\n') - - # write constructor from template ... - code = self.write_function_wrapper(constructor, - self.constructor_tmpl, - handle_return=0, is_method=0, kwargs_needed=1, - substdict=self.get_initial_constructor_substdict( - constructor))[0] - self.fp.write(code) - initfunc = '_wrap_' + funcname - except argtypes.ArgTypeError, ex: - sys.stderr.write('Could not write constructor for %s: %s\n' - % (self.objinfo.c_name, str(ex))) - - initfunc = self.write_noconstructor() - return initfunc - - def write_noconstructor(self): - # this is a hack ... - if not hasattr(self.overrides, 'no_constructor_written'): - self.fp.write(self.noconstructor) - self.overrides.no_constructor_written = 1 - initfunc = 'pygobject_no_constructor' - return initfunc - - def write_default_constructor(self): - return self.write_noconstructor() - - def get_methflags(self, funcname): - if self.overrides.wants_kwargs(funcname): - flags = 'METH_VARARGS|METH_KEYWORDS' - elif self.overrides.wants_noargs(funcname): - flags = 'METH_NOARGS' - elif self.overrides.wants_onearg(funcname): - flags = 'METH_O' - else: - flags = 'METH_VARARGS' - if self.overrides.is_staticmethod(funcname): - flags += '|METH_STATIC' - elif self.overrides.is_classmethod(funcname): - flags += '|METH_CLASS' - return flags - - def write_function(self, funcname, data): - lineno, filename = self.overrides.getstartline(funcname) - self.fp.setline(lineno, filename) - self.fp.write(data) - self.fp.resetline() - self.fp.write('\n\n') - - def _get_class_virtual_substdict(self, meth, cname, parent): - substdict = self.get_initial_method_substdict(meth) - substdict['virtual'] = meth.name - substdict['cname'] = cname - substdict['class_cast_macro'] = parent.typecode.replace( - '_TYPE_', '_', 1) + "_CLASS" - substdict['typecode'] = self.objinfo.typecode - substdict['cast'] = string.replace(parent.typecode, '_TYPE_', '_', 1) - return substdict - - def write_methods(self): - methods = [] - klass = self.objinfo.c_name - # First, get methods from the defs files - for meth in self.parser.find_methods(self.objinfo): - method_name = meth.c_name - if self.overrides.is_ignored(method_name): - continue - try: - if self.overrides.is_overriden(method_name): - if not self.overrides.is_already_included(method_name): - data = self.overrides.override(method_name) - self.write_function(method_name, data) - - methflags = self.get_methflags(method_name) - else: - # write constructor from template ... - code, methflags = self.write_function_wrapper(meth, - self.method_tmpl, handle_return=1, is_method=1, - substdict=self.get_initial_method_substdict(meth)) - self.fp.write(code) - methods.append(self.methdef_tmpl % - { 'name': fixname(meth.name), - 'cname': '_wrap_' + method_name, - 'flags': methflags, - 'docstring': meth.docstring }) - methods_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - methods_coverage.declare_not_wrapped() - sys.stderr.write('Could not write method %s.%s: %s\n' - % (klass, meth.name, str(ex))) - - # Now try to see if there are any defined in the override - for method_name in self.overrides.get_defines_for(klass): - c_name = override.class2cname(klass, method_name) - if self.overrides.is_already_included(method_name): - continue - - try: - data = self.overrides.define(klass, method_name) - self.write_function(method_name, data) - methflags = self.get_methflags(method_name) - - methods.append(self.methdef_tmpl % - { 'name': method_name, - 'cname': '_wrap_' + c_name, - 'flags': methflags, - 'docstring': 'NULL' }) - methods_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - methods_coverage.declare_not_wrapped() - sys.stderr.write('Could not write method %s.%s: %s\n' - % (klass, method_name, str(ex))) - - # Add GObject virtual method accessors, for chaining to parent - # virtuals from subclasses - methods += self.write_virtual_accessors() - - if methods: - methoddefs = '_Py%s_methods' % self.objinfo.c_name - # write the PyMethodDef structure - methods.append(' { NULL, NULL, 0, NULL }\n') - self.fp.write('static const PyMethodDef %s[] = {\n' % methoddefs) - self.fp.write(string.join(methods, '')) - self.fp.write('};\n\n') - else: - methoddefs = 'NULL' - return methoddefs - - def write_virtual_accessors(self): - klass = self.objinfo.c_name - methods = [] - for meth in self.parser.find_virtuals(self.objinfo): - method_name = self.objinfo.c_name + "__do_" + meth.name - if self.overrides.is_ignored(method_name): - continue - try: - if self.overrides.is_overriden(method_name): - if not self.overrides.is_already_included(method_name): - data = self.overrides.override(method_name) - self.write_function(method_name, data) - methflags = self.get_methflags(method_name) - else: - # temporarily add a 'self' parameter as first argument - meth.params.insert(0, definitions.Parameter( - ptype=(self.objinfo.c_name + '*'), - pname='self', pdflt=None, pnull=None)) - try: - # write method from template ... - code, methflags = self.write_function_wrapper( - meth, self.virtual_accessor_tmpl, - handle_return=True, is_method=False, - substdict=self._get_class_virtual_substdict( - meth, method_name, self.objinfo)) - self.fp.write(code) - finally: - del meth.params[0] - methods.append(self.methdef_tmpl % - { 'name': "do_" + fixname(meth.name), - 'cname': '_wrap_' + method_name, - 'flags': methflags + '|METH_CLASS', - 'docstring': 'NULL'}) - vaccessors_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - vaccessors_coverage.declare_not_wrapped() - sys.stderr.write( - 'Could not write virtual accessor method %s.%s: %s\n' - % (klass, meth.name, str(ex))) - return methods - - def write_virtuals(self): - ''' - Write _wrap_FooBar__proxy_do_zbr() reverse wrapers for - GObject virtuals - ''' - klass = self.objinfo.c_name - virtuals = [] - for meth in self.parser.find_virtuals(self.objinfo): - method_name = self.objinfo.c_name + "__proxy_do_" + meth.name - if self.overrides.is_ignored(method_name): - continue - try: - if self.overrides.is_overriden(method_name): - if not self.overrides.is_already_included(method_name): - data = self.overrides.override(method_name) - self.write_function(method_name, data) - else: - # write virtual proxy ... - ret, props = argtypes.matcher.get_reverse_ret(meth.ret) - wrapper = reversewrapper.ReverseWrapper( - '_wrap_' + method_name, is_static=True) - wrapper.set_return_type(ret(wrapper, **props)) - wrapper.add_parameter(reversewrapper.PyGObjectMethodParam( - wrapper, "self", method_name="do_" + meth.name, - c_type=(klass + ' *'))) - for param in meth.params: - handler, props = argtypes.matcher.get_reverse( - param.ptype) - props["direction"] = param.pdir - props["nullok"] = param.pnull - wrapper.add_parameter(handler(wrapper, - param.pname, **props)) - buf = reversewrapper.MemoryCodeSink() - wrapper.generate(buf) - self.fp.write(buf.flush()) - virtuals.append((fixname(meth.name), '_wrap_' + method_name)) - vproxies_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - vproxies_coverage.declare_not_wrapped() - virtuals.append((fixname(meth.name), None)) - sys.stderr.write('Could not write virtual proxy %s.%s: %s\n' - % (klass, meth.name, str(ex))) - if virtuals: - # Write a 'pygtk class init' function for this object, - # except when the object type is explicitly ignored (like - # GtkPlug and GtkSocket on win32). - if self.overrides.is_ignored(self.objinfo.typecode): - return - class_cast_macro = self.objinfo.typecode.replace( - '_TYPE_', '_', 1) + "_CLASS" - cast_macro = self.objinfo.typecode.replace('_TYPE_', '_', 1) - funcname = "__%s_class_init" % klass - self.objinfo.class_init_func = funcname - have_implemented_virtuals = not not [True - for name, cname in virtuals - if cname is not None] - self.fp.write( - ('\nstatic int\n' - '%(funcname)s(gpointer gclass, PyTypeObject *pyclass)\n' - '{\n') % vars()) - - if have_implemented_virtuals: - self.fp.write(' PyObject *o;\n') - self.fp.write( - ' %(klass)sClass *klass = ' - '%(class_cast_macro)s(gclass);\n' - ' PyObject *gsignals = ' - 'PyDict_GetItemString(pyclass->tp_dict, "__gsignals__");\n' - % vars()) - - for name, cname in virtuals: - do_name = 'do_' + name - if cname is None: - self.fp.write('\n /* overriding %(do_name)s ' - 'is currently not supported */\n' % vars()) - else: - self.fp.write(''' - o = PyObject_GetAttrString((PyObject *) pyclass, "%(do_name)s"); - if (o == NULL) - PyErr_Clear(); - else { - if (!PyObject_TypeCheck(o, &PyCFunction_Type) - && !(gsignals && PyDict_GetItemString(gsignals, "%(name)s"))) - klass->%(name)s = %(cname)s; - Py_DECREF(o); - } -''' % vars()) - self.fp.write(' return 0;\n}\n') - - def write_getsets(self): - lower_name = self.get_lower_name() - getsets_name = lower_name + '_getsets' - getterprefix = '_wrap_' + lower_name + '__get_' - setterprefix = '_wrap_' + lower_name + '__set_' - - # no overrides for the whole function. If no fields, - # don't write a func - if not self.objinfo.fields: - return '0' - getsets = [] - for ftype, cfname in self.objinfo.fields: - fname = cfname.replace('.', '_') - gettername = '0' - settername = '0' - attrname = self.objinfo.c_name + '.' + fname - if self.overrides.attr_is_overriden(attrname): - code = self.overrides.attr_override(attrname) - self.write_function(attrname, code) - if string.find(code, getterprefix + fname) >= 0: - gettername = getterprefix + fname - if string.find(code, setterprefix + fname) >= 0: - settername = setterprefix + fname - if gettername == '0': - try: - funcname = getterprefix + fname - info = argtypes.WrapperInfo() - handler = argtypes.matcher.get(ftype) - # for attributes, we don't own the "return value" - handler.write_return(ftype, 0, info) - self.fp.write(self.getter_tmpl % - { 'funcname': funcname, - 'varlist': info.varlist, - 'field': self.get_field_accessor(cfname), - 'codeafter': info.get_codeafter() }) - gettername = funcname - except argtypes.ArgTypeError, ex: - sys.stderr.write( - "Could not write getter for %s.%s: %s\n" - % (self.objinfo.c_name, fname, str(ex))) - if gettername != '0' or settername != '0': - getsets.append(' { "%s", (getter)%s, (setter)%s },\n' % - (fixname(fname), gettername, settername)) - - if not getsets: - return '0' - self.fp.write('static const PyGetSetDef %s[] = {\n' % getsets_name) - for getset in getsets: - self.fp.write(getset) - self.fp.write(' { NULL, (getter)0, (setter)0 },\n') - self.fp.write('};\n\n') - - return getsets_name - - def _write_get_symbol_names(self, writer, functions): - self.fp.write("""static PyObject * -_wrap__get_symbol_names(PyObject *self) -{ - PyObject *pylist = PyList_New(0); - -""") - for obj, bases in writer.get_classes(): - self.fp.write(' PyList_Append(pylist, ' - 'PyString_FromString("%s"));\n' % (obj.name)) - - for name, cname, flags, docstring in functions: - self.fp.write(' PyList_Append(pylist, ' - 'PyString_FromString("%s"));\n' % (name)) - - for enum in writer.get_enums(): - self.fp.write(' PyList_Append(pylist, ' - 'PyString_FromString("%s"));\n' % (enum.name)) - for nick, value in enum.values: - name = value[len(self.overrides.modulename)+1:] - self.fp.write(' PyList_Append(pylist, ' - 'PyString_FromString("%s"));\n' % (name)) - - self.fp.write(" return pylist;\n}\n\n"); - - def _write_get_symbol(self, writer, functions): - self.fp.write("""static PyObject * -_wrap__get_symbol(PyObject *self, PyObject *args) -{ - PyObject *d; - char *name; - static PyObject *modulename = NULL; - static PyObject *module = NULL; - static char *strip_prefix = "%s"; - - if (!PyArg_ParseTuple(args, "Os", &d, &name)) - return NULL; - - if (!modulename) - modulename = PyString_FromString("%s"); - - if (!module) - module = PyDict_GetItemString(d, "__module__"); - -""" % (self.overrides.modulename.upper() + '_', - self.overrides.modulename)) - - first = True - # Classes / GObjects - for obj, bases in writer.get_classes(): - if first: - self.fp.write(' if (!strcmp(name, "%s")) {\n' % obj.name) - first = False - else: - self.fp.write(' } else if (!strcmp(name, "%s")) {\n' % obj.name) - self.fp.write( - ' return (PyObject*)pygobject_lookup_class(%s);\n' % - obj.typecode) - self.fp.write(' }\n') - - # Functions - for name, cname, flags, docstring in functions: - self.fp.write(' else if (!strcmp(name, "%s")) {\n' % name) - self.fp.write(' static PyMethodDef ml = { ' - '"%s", (PyCFunction)%s, %s, "%s"};\n' % ( - name, cname, flags, docstring)) - self.fp.write(' return PyCFunction_NewEx(&ml, NULL, modulename);\n') - self.fp.write(' }\n') - - # Enums - def write_enum(enum, returnobj=False): - if returnobj: - ret = 'return ' - else: - ret = '' - if enum.deftype == 'enum': - self.fp.write( - ' %spyg_enum_add(module, "%s", strip_prefix, %s);\n' - % (ret, enum.name, enum.typecode)) - else: - self.fp.write( - ' %spyg_flags_add(module, "%s", strip_prefix, %s);\n' - % (ret, enum.name, enum.typecode)) - - strip_len = len(self.overrides.modulename)+1 # GTK_ - for enum in writer.get_enums(): - # XXX: Implement without typecodes - self.fp.write(' else if (!strcmp(name, "%s")) {\n' % enum.name) - write_enum(enum, returnobj=True) - self.fp.write(' }\n') - - for nick, value in enum.values: - value = value[strip_len:] - self.fp.write(' else if (!strcmp(name, "%s")) {\n' % value) - write_enum(enum) - self.fp.write(' return PyObject_GetAttrString(module, "%s");\n' % - value) - self.fp.write(' }\n') - - self.fp.write(' return Py_None;\n}\n\n'); - - def _write_function_bodies(self): - functions = [] - # First, get methods from the defs files - for func in self.parser.find_functions(): - funcname = func.c_name - if self.overrides.is_ignored(funcname): - continue - try: - if self.overrides.is_overriden(funcname): - data = self.overrides.override(funcname) - self.write_function(funcname, data) - - methflags = self.get_methflags(funcname) - else: - # write constructor from template ... - code, methflags = self.write_function_wrapper(func, - self.function_tmpl, handle_return=1, is_method=0) - self.fp.write(code) - functions.append((func.name, '_wrap_' + funcname, - methflags, func.docstring)) - functions_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - functions_coverage.declare_not_wrapped() - sys.stderr.write('Could not write function %s: %s\n' - % (func.name, str(ex))) - - # Now try to see if there are any defined in the override - for funcname in self.overrides.get_functions(): - try: - data = self.overrides.function(funcname) - self.write_function(funcname, data) - methflags = self.get_methflags(funcname) - functions.append((funcname, '_wrap_' + funcname, - methflags, 'NULL')) - functions_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - functions_coverage.declare_not_wrapped() - sys.stderr.write('Could not write function %s: %s\n' - % (funcname, str(ex))) - return functions - - def write_functions(self, writer, prefix): - self.fp.write('\n/* ----------- functions ----------- */\n\n') - functions = [] - func_infos = self._write_function_bodies() - - # If we have a dynamic namespace, write symbol and attribute getter - if self.overrides.dynamicnamespace: - self._write_get_symbol_names(writer, func_infos) - self._write_get_symbol(writer, func_infos) - for obj, bases in writer.get_classes(): - self.fp.write("""static PyTypeObject * -%s_register_type(const gchar *name, PyObject *unused) -{ - PyObject *m = PyImport_ImportModule("gtk"); - PyObject *d = PyModule_GetDict(m); -""" % obj.c_name) - writer.write_class(obj, bases, indent=1) - self.fp.write( - ' return (%s)PyDict_GetItemString(d, "%s");\n' % ( - 'PyTypeObject*', obj.name)) - self.fp.write("}\n") - - functions.append(' { "_get_symbol_names", ' - '(PyCFunction)_wrap__get_symbol_names, ' - 'METH_NOARGS, NULL },\n') - functions.append(' { "_get_symbol", ' - '(PyCFunction)_wrap__get_symbol, ' - 'METH_VARARGS, NULL },\n') - else: - for name, cname, flags, docstring in func_infos: - functions.append(self.methdef_tmpl % dict(name=name, - cname=cname, - flags=flags, - docstring=docstring)) - - # write the PyMethodDef structure - functions.append(' { NULL, NULL, 0, NULL }\n') - - self.fp.write('const PyMethodDef ' + prefix + '_functions[] = {\n') - self.fp.write(string.join(functions, '')) - self.fp.write('};\n\n') - -class GObjectWrapper(Wrapper): - constructor_tmpl = ( - 'static int\n' - '_wrap_%(cname)s(PyGObject *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' self->obj = (GObject *)%(cname)s(%(arglist)s);\n' - '%(codeafter)s\n' - ' if (!self->obj) {\n' - ' PyErr_SetString(PyExc_RuntimeError, ' - '"could not create %(typename)s object");\n' - ' return -1;\n' - ' }\n' - '%(aftercreate)s' - ' pygobject_register_wrapper((PyObject *)self);\n' - ' return 0;\n' - '}\n\n' - ) - - method_tmpl = ( - 'static PyObject *\n' - '_wrap_%(cname)s(PyGObject *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' %(begin_allow_threads)s\n' - ' %(setreturn)s%(cname)s(%(cast)s(self->obj)%(arglist)s);\n' - ' %(end_allow_threads)s\n' - '%(codeafter)s\n' - '}\n\n' - ) - def __init__(self, parser, objinfo, overrides, fp=FileOutput(sys.stdout)): - Wrapper.__init__(self, parser, objinfo, overrides, fp) - if self.objinfo: - self.castmacro = string.replace(self.objinfo.typecode, - '_TYPE_', '_', 1) - - def get_initial_class_substdict(self): - return { 'tp_basicsize' : 'PyGObject', - 'tp_weaklistoffset' : 'offsetof(PyGObject, weakreflist)', - 'tp_dictoffset' : 'offsetof(PyGObject, inst_dict)' } - - def get_field_accessor(self, fieldname): - castmacro = string.replace(self.objinfo.typecode, '_TYPE_', '_', 1) - return '%s(pygobject_get(self))->%s' % (castmacro, fieldname) - - def get_initial_constructor_substdict(self, constructor): - substdict = Wrapper.get_initial_constructor_substdict(self, - constructor) - if not constructor.caller_owns_return: - substdict['aftercreate'] = " g_object_ref(self->obj);\n" - else: - substdict['aftercreate'] = '' - return substdict - - def get_initial_method_substdict(self, method): - substdict = Wrapper.get_initial_method_substdict(self, method) - substdict['cast'] = string.replace(self.objinfo.typecode, - '_TYPE_', '_', 1) - return substdict - - def write_default_constructor(self): - try: - parent = self.parser.find_object(self.objinfo.parent) - except ValueError: - parent = None - if parent is not None: - ## just like the constructor is inheritted, we should - # inherit the new API compatibility flag - self.objinfo.has_new_constructor_api = ( - parent.has_new_constructor_api) - elif self.objinfo.parent == 'GObject': - self.objinfo.has_new_constructor_api = True - return '0' - - def write_property_based_constructor(self, constructor): - self.objinfo.has_new_constructor_api = True - out = self.fp - print >> out, "static int" - print >> out, '_wrap_%s(PyGObject *self, PyObject *args,' \ - ' PyObject *kwargs)\n{' % constructor.c_name - if constructor.params: - s = " GType obj_type = pyg_type_from_object((PyObject *) self);" - print >> out, s - - def py_str_list_to_c(arg): - if arg: - return "{" + ", ".join( - map(lambda s: '"' + s + '"', arg)) + ", NULL }" - else: - return "{ NULL }" - - classname = '%s.%s' % (self.overrides.modulename, - self.objinfo.name) - - if constructor.params: - mandatory_arguments = [param for param in constructor.params - if not param.optional] - optional_arguments = [param for param in constructor.params - if param.optional] - arg_names = py_str_list_to_c( - [param.argname - for param in mandatory_arguments + optional_arguments]) - - prop_names = py_str_list_to_c( - [param.pname - for param in mandatory_arguments + optional_arguments]) - - print >> out, " GParameter params[%i];" % \ - len(constructor.params) - print >> out, " PyObject *parsed_args[%i] = {NULL, };" % \ - len(constructor.params) - print >> out, " char *arg_names[] = %s;" % arg_names - print >> out, " char *prop_names[] = %s;" % prop_names - print >> out, " guint nparams, i;" - print >> out - if constructor.deprecated is not None: - out.write( - ' if (PyErr_Warn(PyExc_DeprecationWarning, ' - '"%s") < 0)\n' % - constructor.deprecated) - print >> out, ' return -1;' - print >> out - out.write(" if (!PyArg_ParseTupleAndKeywords(args, kwargs, ") - template = '"' - if mandatory_arguments: - template += "O"*len(mandatory_arguments) - if optional_arguments: - template += "|" + "O"*len(optional_arguments) - template += ':%s.__init__"' % classname - print >> out, template, ", arg_names", - for i in range(len(constructor.params)): - print >> out, ", &parsed_args[%i]" % i, - - out.write( - "))\n" - " return -1;\n" - "\n" - " memset(params, 0, sizeof(GParameter)*%i);\n" - " if (!pyg_parse_constructor_args(obj_type, arg_names,\n" - " prop_names, params, \n" - " &nparams, parsed_args))\n" - " return -1;\n" - " pygobject_constructv(self, nparams, params);\n" - " for (i = 0; i < nparams; ++i)\n" - " g_value_unset(¶ms[i].value);\n" - % len(constructor.params)) - else: - out.write( - " static char* kwlist[] = { NULL };\n" - "\n") - - if constructor.deprecated is not None: - out.write( - ' if (PyErr_Warn(PyExc_DeprecationWarning, "%s") < 0)\n' - ' return -1;\n' - '\n' % constructor.deprecated) - - out.write( - ' if (!PyArg_ParseTupleAndKeywords(args, kwargs,\n' - ' ":%s.__init__",\n' - ' kwlist))\n' - ' return -1;\n' - '\n' - ' pygobject_constructv(self, 0, NULL);\n' % classname) - out.write( - ' if (!self->obj) {\n' - ' PyErr_SetString(\n' - ' PyExc_RuntimeError, \n' - ' "could not create %s object");\n' - ' return -1;\n' - ' }\n' % classname) - - if not constructor.caller_owns_return: - print >> out, " g_object_ref(self->obj);\n" - - out.write( - ' return 0;\n' - '}\n\n') - - return "_wrap_%s" % constructor.c_name - - -class GInterfaceWrapper(GObjectWrapper): - virtual_accessor_tmpl = ( - 'static PyObject *\n' - '_wrap_%(cname)s(PyObject *cls%(extraparams)s)\n' - '{\n' - ' %(vtable)s *iface;\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' iface = g_type_interface_peek(' - 'g_type_class_peek(pyg_type_from_object(cls)), %(typecode)s);\n' - ' if (iface->%(virtual)s)\n' - ' %(setreturn)siface->%(virtual)s(%(arglist)s);\n' - ' else {\n' - ' PyErr_SetString(PyExc_NotImplementedError, ' - '"interface method %(name)s not implemented");\n' - ' return NULL;\n' - ' }\n' - '%(codeafter)s\n' - '}\n\n' - ) - - def get_initial_class_substdict(self): - return { 'tp_basicsize' : 'PyObject', - 'tp_weaklistoffset' : '0', - 'tp_dictoffset' : '0'} - - def write_constructor(self): - # interfaces have no constructors ... - return '0' - def write_getsets(self): - # interfaces have no fields ... - return '0' - - def _get_class_virtual_substdict(self, meth, cname, parent): - substdict = self.get_initial_method_substdict(meth) - substdict['virtual'] = meth.name - substdict['cname'] = cname - substdict['typecode'] = self.objinfo.typecode - substdict['vtable'] = self.objinfo.vtable - return substdict - - def write_virtuals(self): - ## Now write reverse method wrappers, which let python code - ## implement interface methods. - # First, get methods from the defs files - klass = self.objinfo.c_name - proxies = [] - for meth in self.parser.find_virtuals(self.objinfo): - method_name = self.objinfo.c_name + "__proxy_do_" + meth.name - if self.overrides.is_ignored(method_name): - continue - try: - if self.overrides.is_overriden(method_name): - if not self.overrides.is_already_included(method_name): - data = self.overrides.override(method_name) - self.write_function(method_name, data) - else: - # write proxy ... - ret, props = argtypes.matcher.get_reverse_ret(meth.ret) - wrapper = reversewrapper.ReverseWrapper( - '_wrap_' + method_name, is_static=True) - wrapper.set_return_type(ret(wrapper, **props)) - wrapper.add_parameter(reversewrapper.PyGObjectMethodParam( - wrapper, "self", method_name="do_" + meth.name, - c_type=(klass + ' *'))) - for param in meth.params: - handler, props = argtypes.matcher.get_reverse( - param.ptype) - props["direction"] = param.pdir - props["nullok"] = param.pnull - wrapper.add_parameter( - handler(wrapper, param.pname, **props)) - buf = reversewrapper.MemoryCodeSink() - wrapper.generate(buf) - self.fp.write(buf.flush()) - proxies.append((fixname(meth.name), '_wrap_' + method_name)) - iproxies_coverage.declare_wrapped() - except argtypes.ArgTypeError, ex: - iproxies_coverage.declare_not_wrapped() - proxies.append((fixname(meth.name), None)) - sys.stderr.write('Could not write interface proxy %s.%s: %s\n' - % (klass, meth.name, str(ex))) - - if not proxies or not [cname for name, cname in proxies if cname]: - return - - ## Write an interface init function for this object - funcname = "__%s__interface_init" % klass - vtable = self.objinfo.vtable - self.fp.write( - '\nstatic void\n' - '%(funcname)s(%(vtable)s *iface, PyTypeObject *pytype)\n' - '{\n' - ' %(vtable)s *parent_iface = ' - 'g_type_interface_peek_parent(iface);\n' - ' PyObject *py_method;\n' - '\n' - % vars()) - - for name, cname in proxies: - do_name = 'do_' + name - if cname is None: - continue - - self.fp.write(( - ' py_method = pytype? PyObject_GetAttrString(' - '(PyObject *) pytype, "%(do_name)s") : NULL;\n' - ' if (py_method && !PyObject_TypeCheck(py_method, ' - '&PyCFunction_Type)) {\n' - ' iface->%(name)s = %(cname)s;\n' - ' } else {\n' - ' PyErr_Clear();\n' - ' if (parent_iface) {\n' - ' iface->%(name)s = parent_iface->%(name)s;\n' - ' }\n' - ' Py_XDECREF(py_method);\n' - ' }\n' - ) % vars()) - self.fp.write('}\n\n') - interface_info = "__%s__iinfo" % klass - self.fp.write(''' -static const GInterfaceInfo %s = { - (GInterfaceInitFunc) %s, - NULL, - NULL -}; -''' % (interface_info, funcname)) - self.objinfo.interface_info = interface_info - -class GBoxedWrapper(Wrapper): - constructor_tmpl = ( - 'static int\n' - '_wrap_%(cname)s(PyGBoxed *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' self->gtype = %(typecode)s;\n' - ' self->free_on_dealloc = FALSE;\n' - ' self->boxed = %(cname)s(%(arglist)s);\n' - '%(codeafter)s\n' - ' if (!self->boxed) {\n' - ' PyErr_SetString(PyExc_RuntimeError, ' - '"could not create %(typename)s object");\n' - ' return -1;\n' - ' }\n' - ' self->free_on_dealloc = TRUE;\n' - ' return 0;\n' - '}\n\n' - ) - - method_tmpl = ( - 'static PyObject *\n' - '_wrap_%(cname)s(PyObject *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' %(begin_allow_threads)s\n' - ' %(setreturn)s%(cname)s(pyg_boxed_get(self, ' - '%(typename)s)%(arglist)s);\n' - ' %(end_allow_threads)s\n' - '%(codeafter)s\n' - '}\n\n' - ) - - def get_initial_class_substdict(self): - return { 'tp_basicsize' : 'PyGBoxed', - 'tp_weaklistoffset' : '0', - 'tp_dictoffset' : '0' } - - def get_field_accessor(self, fieldname): - return 'pyg_boxed_get(self, %s)->%s' % (self.objinfo.c_name, fieldname) - - def get_initial_constructor_substdict(self, constructor): - substdict = Wrapper.get_initial_constructor_substdict( - self, constructor) - substdict['typecode'] = self.objinfo.typecode - return substdict - -class GPointerWrapper(GBoxedWrapper): - constructor_tmpl = ( - 'static int\n' - '_wrap_%(cname)s(PyGPointer *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' self->gtype = %(typecode)s;\n' - ' self->pointer = %(cname)s(%(arglist)s);\n' - '%(codeafter)s\n' - ' if (!self->pointer) {\n' - ' PyErr_SetString(PyExc_RuntimeError, ' - '"could not create %(typename)s object");\n' - ' return -1;\n' - ' }\n' - ' return 0;\n' - '}\n\n' - ) - - method_tmpl = ( - 'static PyObject *\n' - '_wrap_%(cname)s(PyObject *self%(extraparams)s)\n' - '{\n' - '%(varlist)s' - '%(parseargs)s' - '%(codebefore)s' - ' %(setreturn)s%(cname)s(pyg_pointer_get(self, ' - '%(typename)s)%(arglist)s);\n' - '%(codeafter)s\n' - '}\n\n' - ) - - def get_initial_class_substdict(self): - return { 'tp_basicsize' : 'PyGPointer', - 'tp_weaklistoffset' : '0', - 'tp_dictoffset' : '0' } - - def get_field_accessor(self, fieldname): - return 'pyg_pointer_get(self, %s)->%s' % (self.objinfo.c_name, - fieldname) - - def get_initial_constructor_substdict(self, constructor): - substdict = Wrapper.get_initial_constructor_substdict( - self, constructor) - substdict['typecode'] = self.objinfo.typecode - return substdict - -class SourceWriter: - def __init__(self, parser, overrides, prefix, fp=FileOutput(sys.stdout)): - self.parser = parser - self.overrides = overrides - self.prefix = prefix - self.fp = fp - - def write(self, py_ssize_t_clean=False): - argtypes.py_ssize_t_clean = py_ssize_t_clean - - self.write_headers(py_ssize_t_clean) - self.write_imports() - self.write_type_declarations() - self.write_body() - self.write_classes() - - wrapper = Wrapper(self.parser, None, self.overrides, self.fp) - wrapper.write_functions(self, self.prefix) - - if not self.overrides.dynamicnamespace: - self.write_enums() - self.write_extension_init() - self.write_registers() - - argtypes.py_ssize_t_clean = False - - def write_headers(self, py_ssize_t_clean): - self.fp.write('/* -- THIS FILE IS GENERATED - DO NOT EDIT */') - self.fp.write('/* -*- Mode: C; c-basic-offset: 4 -*- */\n\n') - if py_ssize_t_clean: - self.fp.write('#define PY_SSIZE_T_CLEAN\n') - self.fp.write('#include \n\n\n') - if py_ssize_t_clean: - self.fp.write(''' - -#if PY_VERSION_HEX < 0x02050000 -typedef int Py_ssize_t; -#define PY_SSIZE_T_MAX INT_MAX -#define PY_SSIZE_T_MIN INT_MIN -typedef inquiry lenfunc; -typedef intargfunc ssizeargfunc; -typedef intobjargproc ssizeobjargproc; -#endif - -''') - self.fp.write(self.overrides.get_headers()) - self.fp.resetline() - self.fp.write('\n\n') - - def write_imports(self): - self.fp.write('/* ---------- types from other modules ---------- */\n') - for module, pyname, cname, importing_for in self.overrides.get_imports(): - if importing_for is None or is_registered_object(importing_for): - self.fp.write('static PyTypeObject *_%s;\n' % cname) - self.fp.write('#define %s (*_%s)\n' % (cname, cname)) - self.fp.write('\n\n') - - def write_type_declarations(self): - #todo use 'static' if used only in one file - self.fp.write('/* ---------- forward type declarations ---------- */\n') - for obj in self.parser.boxes: - if not self.overrides.is_type_ignored(obj.c_name): - self.fp.write('PyTypeObject G_GNUC_INTERNAL Py' + obj.c_name + '_Type;\n') - for obj in self.parser.objects: - if not self.overrides.is_type_ignored(obj.c_name): - self.fp.write('PyTypeObject G_GNUC_INTERNAL Py' + obj.c_name + '_Type;\n') - for interface in self.parser.interfaces: - if not self.overrides.is_type_ignored(interface.c_name): - self.fp.write('PyTypeObject G_GNUC_INTERNAL Py' + interface.c_name + '_Type;\n') - self.fp.write('\n') - - def write_body(self): - self.fp.write(self.overrides.get_body()) - self.fp.resetline() - self.fp.write('\n\n') - - def _sort_parent_children(self, objects): - objects = list(objects) - modified = True - while modified: - modified = False - parent_index = None - child_index = None - for i, obj in enumerate(objects): - if obj.parent == 'GObject': - continue - if obj.parent not in [info.c_name for info in objects[:i]]: - for j, info in enumerate(objects[i+1:]): - if info.c_name == obj.parent: - parent_index = i + 1 + j - child_index = i - break - else: - continue - break - if child_index is not None and parent_index is not None: - if child_index != parent_index: - objects.insert(child_index, objects.pop(parent_index)) - modified = True - return objects - - def write_classes(self): - ## Sort the objects, so that we generate code for the parent types - ## before their children. - objects = self._sort_parent_children(self.parser.objects) - - for klass, items in ((GBoxedWrapper, self.parser.boxes), - (GPointerWrapper, self.parser.pointers), - (GObjectWrapper, objects), - (GInterfaceWrapper, self.parser.interfaces)): - for item in items: - instance = klass(self.parser, item, self.overrides, self.fp) - instance.write_class() - self.fp.write('\n') - - def get_enums(self): - enums = [] - for enum in self.parser.enums: - if self.overrides.is_type_ignored(enum.c_name): - continue - enums.append(enum) - return enums - - def write_enums(self): - if not self.parser.enums: - return - - self.fp.write('\n/* ----------- enums and flags ----------- */\n\n') - self.fp.write( - 'void\n' + self.prefix + - '_add_constants(PyObject *module, const gchar *strip_prefix)\n{\n') - - self.fp.write( - '#ifdef VERSION\n' - ' PyModule_AddStringConstant(module, "__version__", VERSION);\n' - '#endif\n') - - for enum in self.get_enums(): - if enum.typecode is None: - for nick, value in enum.values: - self.fp.write( - ' PyModule_AddIntConstant(module, ' - '(char *) pyg_constant_strip_prefix("%s", strip_prefix), %s);\n' - % (value, value)) - else: - if enum.deftype == 'enum': - self.fp.write(' pyg_enum_add(module, "%s", strip_prefix, %s);\n' - % (enum.name, enum.typecode)) - else: - self.fp.write(' pyg_flags_add(module, "%s", strip_prefix, %s);\n' - % (enum.name, enum.typecode)) - - self.fp.write('\n') - self.fp.write(' if (PyErr_Occurred())\n') - self.fp.write(' PyErr_Print();\n') - self.fp.write('}\n\n') - - def write_object_imports(self, retval=''): - imports = self.overrides.get_imports()[:] - if not imports: - return - - bymod = {} - for module, pyname, cname, importing_for in imports: - if importing_for is None or is_registered_object(importing_for): - bymod.setdefault(module, []).append((pyname, cname)) - self.fp.write(' PyObject *module;\n\n') - for module in bymod: - self.fp.write( - ' if ((module = PyImport_ImportModule("%s")) != NULL) {\n' - % module) - #self.fp.write( - # ' PyObject *moddict = PyModule_GetDict(module);\n\n') - for pyname, cname in bymod[module]: - #self.fp.write( - # ' _%s = (PyTypeObject *)PyDict_GetItemString(' - # 'moddict, "%s");\n' % (cname, pyname)) - self.fp.write( - ' _%s = (PyTypeObject *)PyObject_GetAttrString(' - 'module, "%s");\n' % (cname, pyname)) - self.fp.write(' if (_%s == NULL) {\n' % cname) - self.fp.write(' PyErr_SetString(PyExc_ImportError,\n') - self.fp.write(' "cannot import name %s from %s");\n' - % (pyname, module)) - self.fp.write(' return %s;\n' % retval) - self.fp.write(' }\n') - self.fp.write(' } else {\n') - self.fp.write(' PyErr_SetString(PyExc_ImportError,\n') - self.fp.write(' "could not import %s");\n' % module) - self.fp.write(' return %s;\n' % retval) - self.fp.write(' }\n') - self.fp.write('\n') - - def write_extension_init(self): - self.fp.write('/* initialise stuff extension classes */\n') - self.fp.write('void\n' + self.prefix + '_register_classes(PyObject *d)\n{\n') - self.write_object_imports() - self.fp.write(self.overrides.get_init() + '\n') - self.fp.resetline() - - def get_classes(self): - objects = self.parser.objects[:] - pos = 0 - while pos < len(objects): - parent = objects[pos].parent - for i in range(pos+1, len(objects)): - if objects[i].c_name == parent: - objects.insert(i+1, objects[pos]) - del objects[pos] - break - else: - pos = pos + 1 - - retval = [] - for obj in objects: - if self.overrides.is_type_ignored(obj.c_name): - continue - bases = [] - if obj.parent != None: - bases.append(obj.parent) - bases = bases + obj.implements - retval.append((obj, bases)) - - return retval - - def write_registers(self): - for boxed in self.parser.boxes: - if not self.overrides.is_type_ignored(boxed.c_name): - self.fp.write(' pyg_register_boxed(d, "' + boxed.name + - '", ' + boxed.typecode + - ', &Py' + boxed.c_name + - '_Type);\n') - for pointer in self.parser.pointers: - if not self.overrides.is_type_ignored(pointer.c_name): - self.fp.write(' pyg_register_pointer(d, "' + pointer.name + - '", ' + pointer.typecode + - ', &Py' + pointer.c_name + '_Type);\n') - for interface in self.parser.interfaces: - if not self.overrides.is_type_ignored(interface.c_name): - self.fp.write(' pyg_register_interface(d, "' - + interface.name + '", '+ interface.typecode - + ', &Py' + interface.c_name + '_Type);\n') - if interface.interface_info is not None: - self.fp.write(' pyg_register_interface_info(%s, &%s);\n' % - (interface.typecode, interface.interface_info)) - - if not self.overrides.dynamicnamespace: - for obj, bases in self.get_classes(): - self.write_class(obj, bases) - else: - for obj, bases in self.get_classes(): - self.fp.write( - ' pyg_type_register_custom_callback("%s", ' - '(PyGTypeRegistrationFunction)%s_register_type, d);\n' % - (obj.c_name, obj.c_name)) - - self.fp.write('}\n') - - def _can_direct_ref(self, base): - if not self.overrides.dynamicnamespace: - return True - if base == 'GObject': - return True - obj = get_object_by_name(base) - if obj.module.lower() != self.overrides.modulename: - return True - return False - - def write_class(self, obj, bases, indent=1): - indent_str = ' ' * (indent * 4) - if bases: - bases_str = 'Py_BuildValue("(%s)"' % (len(bases) * 'O') - - for base in bases: - if self._can_direct_ref(base): - bases_str += ', &Py%s_Type' % base - else: - baseobj = get_object_by_name(base) - bases_str += ', PyObject_GetAttrString(m, "%s")' % baseobj.name - bases_str += ')' - else: - bases_str = 'NULL' - - self.fp.write( - '%(indent)spygobject_register_class(d, "%(c_name)s", %(typecode)s, &Py%(c_name)s_Type, %(bases)s);\n' - % dict(indent=indent_str, c_name=obj.c_name, typecode=obj.typecode, bases=bases_str)) - - if obj.has_new_constructor_api: - self.fp.write( - indent_str + 'pyg_set_object_has_new_constructor(%s);\n' % - obj.typecode) - else: - print >> sys.stderr, ( - "Warning: Constructor for %s needs to be updated to new API\n" - " See http://live.gnome.org/PyGTK_2fWhatsNew28" - "#update-constructors") % obj.c_name - - if obj.class_init_func is not None: - self.fp.write( - indent_str + 'pyg_register_class_init(%s, %s);\n' % - (obj.typecode, obj.class_init_func)) - -_objects = {} - -def is_registered_object(c_name): - return c_name in _objects - -def get_object_by_name(c_name): - global _objects - return _objects[c_name] - -def register_types(parser): - global _objects - for boxed in parser.boxes: - argtypes.matcher.register_boxed(boxed.c_name, boxed.typecode) - _objects[boxed.c_name] = boxed - for pointer in parser.pointers: - argtypes.matcher.register_pointer(pointer.c_name, pointer.typecode) - for obj in parser.objects: - argtypes.matcher.register_object(obj.c_name, obj.parent, obj.typecode) - _objects[obj.c_name] = obj - for iface in parser.interfaces: - argtypes.matcher.register_object(iface.c_name, None, iface.typecode) - _objects[iface.c_name] = iface - for enum in parser.enums: - if enum.deftype == 'flags': - argtypes.matcher.register_flag(enum.c_name, enum.typecode) - else: - argtypes.matcher.register_enum(enum.c_name, enum.typecode) - -usage = 'usage: codegen.py [-o overridesfile] [-p prefix] defsfile' -def main(argv): - o = override.Overrides() - prefix = 'pygtk' - outfilename = None - errorfilename = None - opts, args = getopt.getopt(argv[1:], "o:p:r:t:D:I:", - ["override=", "prefix=", "register=", "outfilename=", - "load-types=", "errorfilename=", "py_ssize_t-clean"]) - defines = {} # -Dkey[=val] options - py_ssize_t_clean = False - for opt, arg in opts: - if opt in ('-o', '--override'): - o = override.Overrides(arg) - elif opt in ('-p', '--prefix'): - prefix = arg - elif opt in ('-r', '--register'): - # Warning: user has to make sure all -D options appear before -r - p = defsparser.DefsParser(arg, defines) - p.startParsing() - register_types(p) - del p - elif opt == '--outfilename': - outfilename = arg - elif opt == '--errorfilename': - errorfilename = arg - elif opt in ('-t', '--load-types'): - globals = {} - execfile(arg, globals) - elif opt == '-D': - nameval = arg.split('=') - try: - defines[nameval[0]] = nameval[1] - except IndexError: - defines[nameval[0]] = None - elif opt == '-I': - defsparser.include_path.insert(0, arg) - elif opt == '--py_ssize_t-clean': - py_ssize_t_clean = True - if len(args) < 1: - print >> sys.stderr, usage - return 1 - if errorfilename: - sys.stderr = open(errorfilename, "w") - p = defsparser.DefsParser(args[0], defines) - if not outfilename: - outfilename = os.path.splitext(args[0])[0] + '.c' - - p.startParsing() - - register_types(p) - sw = SourceWriter(p, o, prefix, FileOutput(sys.stdout, outfilename)) - sw.write(py_ssize_t_clean) - - functions_coverage.printstats() - methods_coverage.printstats() - vproxies_coverage.printstats() - vaccessors_coverage.printstats() - iproxies_coverage.printstats() - -if __name__ == '__main__': - sys.exit(main(sys.argv)) diff --git a/bindings/python/codegen/definitions.py b/bindings/python/codegen/definitions.py deleted file mode 100644 index bfb6faffb1..0000000000 --- a/bindings/python/codegen/definitions.py +++ /dev/null @@ -1,575 +0,0 @@ -# -*- Mode: Python; py-indent-offset: 4 -*- -import copy -import sys - -def get_valid_scheme_definitions(defs): - return [x for x in defs if isinstance(x, tuple) and len(x) >= 2] - -def unescape(s): - s = s.replace('\r\n', '\\r\\n').replace('\t', '\\t') - return s.replace('\r', '\\r').replace('\n', '\\n') - -def make_docstring(lines): - return "(char *) " + '\n'.join(['"%s"' % unescape(s) for s in lines]) - -# New Parameter class, wich emulates a tuple for compatibility reasons -class Parameter(object): - def __init__(self, ptype, pname, pdflt, pnull, pdir=None): - self.ptype = ptype - self.pname = pname - self.pdflt = pdflt - self.pnull = pnull - self.pdir = pdir - - def __len__(self): return 4 - def __getitem__(self, i): - return (self.ptype, self.pname, self.pdflt, self.pnull)[i] - - def merge(self, old): - if old.pdflt is not None: - self.pdflt = old.pdflt - if old.pnull is not None: - self.pnull = old.pnull - -# We currently subclass 'str' to make impact on the rest of codegen as -# little as possible. Later we can subclass 'object' instead, but -# then we must find and adapt all places which expect return types to -# be strings. -class ReturnType(str): - def __new__(cls, *args, **kwds): - return str.__new__(cls, *args[:1]) - def __init__(self, type_name, optional=False): - str.__init__(self) - self.optional = optional - -# Parameter for property based constructors -class Property(object): - def __init__(self, pname, optional, argname): - self.pname = pname - self.optional = optional - self.argname = argname - - def __len__(self): return 4 - def __getitem__(self, i): - return ('', self.pname, self.optional, self.argname)[i] - - def merge(self, old): - if old.optional is not None: - self.optional = old.optional - if old.argname is not None: - self.argname = old.argname - - -class Definition(object): - docstring = "NULL" - - def py_name(self): - return '%s.%s' % (self.module, self.name) - - py_name = property(py_name) - - def __init__(self, *args): - """Create a new defs object of this type. The arguments are the - components of the definition""" - raise RuntimeError("this is an abstract class") - - def merge(self, old): - """Merge in customisations from older version of definition""" - raise RuntimeError("this is an abstract class") - - def write_defs(self, fp=sys.stdout): - """write out this definition in defs file format""" - raise RuntimeError("this is an abstract class") - - def guess_return_value_ownership(self): - "return 1 if caller owns return value" - if getattr(self, 'is_constructor_of', False): - self.caller_owns_return = True - elif self.ret in ('char*', 'gchar*', 'string'): - self.caller_owns_return = True - else: - self.caller_owns_return = False - - -class ObjectDef(Definition): - def __init__(self, name, *args): - self.name = name - self.module = None - self.parent = None - self.c_name = None - self.typecode = None - self.fields = [] - self.implements = [] - self.class_init_func = None - self.has_new_constructor_api = False - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'in-module': - self.module = arg[1] - elif arg[0] == 'docstring': - self.docstring = make_docstring(arg[1:]) - elif arg[0] == 'parent': - self.parent = arg[1] - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'fields': - for parg in arg[1:]: - self.fields.append((parg[0], parg[1])) - elif arg[0] == 'implements': - self.implements.append(arg[1]) - def merge(self, old): - # currently the .h parser doesn't try to work out what fields of - # an object structure should be public, so we just copy the list - # from the old version ... - self.fields = old.fields - self.implements = old.implements - def write_defs(self, fp=sys.stdout): - fp.write('(define-object ' + self.name + '\n') - if self.module: - fp.write(' (in-module "' + self.module + '")\n') - if self.parent != (None, None): - fp.write(' (parent "' + self.parent + '")\n') - for interface in self.implements: - fp.write(' (implements "' + interface + '")\n') - if self.c_name: - fp.write(' (c-name "' + self.c_name + '")\n') - if self.typecode: - fp.write(' (gtype-id "' + self.typecode + '")\n') - if self.fields: - fp.write(' (fields\n') - for (ftype, fname) in self.fields: - fp.write(' \'("' + ftype + '" "' + fname + '")\n') - fp.write(' )\n') - fp.write(')\n\n') - -class InterfaceDef(Definition): - def __init__(self, name, *args): - self.name = name - self.module = None - self.c_name = None - self.typecode = None - self.vtable = None - self.fields = [] - self.interface_info = None - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'in-module': - self.module = arg[1] - elif arg[0] == 'docstring': - self.docstring = make_docstring(arg[1:]) - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'vtable': - self.vtable = arg[1] - if self.vtable is None: - self.vtable = self.c_name + "Iface" - def write_defs(self, fp=sys.stdout): - fp.write('(define-interface ' + self.name + '\n') - if self.module: - fp.write(' (in-module "' + self.module + '")\n') - if self.c_name: - fp.write(' (c-name "' + self.c_name + '")\n') - if self.typecode: - fp.write(' (gtype-id "' + self.typecode + '")\n') - fp.write(')\n\n') - -class EnumDef(Definition): - def __init__(self, name, *args): - self.deftype = 'enum' - self.name = name - self.in_module = None - self.c_name = None - self.typecode = None - self.values = [] - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'in-module': - self.in_module = arg[1] - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'values': - for varg in arg[1:]: - self.values.append((varg[0], varg[1])) - def merge(self, old): - pass - def write_defs(self, fp=sys.stdout): - fp.write('(define-' + self.deftype + ' ' + self.name + '\n') - if self.in_module: - fp.write(' (in-module "' + self.in_module + '")\n') - fp.write(' (c-name "' + self.c_name + '")\n') - fp.write(' (gtype-id "' + self.typecode + '")\n') - if self.values: - fp.write(' (values\n') - for name, val in self.values: - fp.write(' \'("' + name + '" "' + val + '")\n') - fp.write(' )\n') - fp.write(')\n\n') - -class FlagsDef(EnumDef): - def __init__(self, *args): - apply(EnumDef.__init__, (self,) + args) - self.deftype = 'flags' - -class BoxedDef(Definition): - def __init__(self, name, *args): - self.name = name - self.module = None - self.c_name = None - self.typecode = None - self.copy = None - self.release = None - self.fields = [] - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'in-module': - self.module = arg[1] - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'copy-func': - self.copy = arg[1] - elif arg[0] == 'release-func': - self.release = arg[1] - elif arg[0] == 'fields': - for parg in arg[1:]: - self.fields.append((parg[0], parg[1])) - def merge(self, old): - # currently the .h parser doesn't try to work out what fields of - # an object structure should be public, so we just copy the list - # from the old version ... - self.fields = old.fields - def write_defs(self, fp=sys.stdout): - fp.write('(define-boxed ' + self.name + '\n') - if self.module: - fp.write(' (in-module "' + self.module + '")\n') - if self.c_name: - fp.write(' (c-name "' + self.c_name + '")\n') - if self.typecode: - fp.write(' (gtype-id "' + self.typecode + '")\n') - if self.copy: - fp.write(' (copy-func "' + self.copy + '")\n') - if self.release: - fp.write(' (release-func "' + self.release + '")\n') - if self.fields: - fp.write(' (fields\n') - for (ftype, fname) in self.fields: - fp.write(' \'("' + ftype + '" "' + fname + '")\n') - fp.write(' )\n') - fp.write(')\n\n') - -class PointerDef(Definition): - def __init__(self, name, *args): - self.name = name - self.module = None - self.c_name = None - self.typecode = None - self.fields = [] - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'in-module': - self.module = arg[1] - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'fields': - for parg in arg[1:]: - self.fields.append((parg[0], parg[1])) - def merge(self, old): - # currently the .h parser doesn't try to work out what fields of - # an object structure should be public, so we just copy the list - # from the old version ... - self.fields = old.fields - def write_defs(self, fp=sys.stdout): - fp.write('(define-pointer ' + self.name + '\n') - if self.module: - fp.write(' (in-module "' + self.module + '")\n') - if self.c_name: - fp.write(' (c-name "' + self.c_name + '")\n') - if self.typecode: - fp.write(' (gtype-id "' + self.typecode + '")\n') - if self.fields: - fp.write(' (fields\n') - for (ftype, fname) in self.fields: - fp.write(' \'("' + ftype + '" "' + fname + '")\n') - fp.write(' )\n') - fp.write(')\n\n') - -class MethodDefBase(Definition): - def __init__(self, name, *args): - dump = 0 - self.name = name - self.ret = None - self.caller_owns_return = None - self.unblock_threads = None - self.c_name = None - self.typecode = None - self.of_object = None - self.params = [] # of form (type, name, default, nullok) - self.varargs = 0 - self.deprecated = None - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'of-object': - self.of_object = arg[1] - elif arg[0] == 'docstring': - self.docstring = make_docstring(arg[1:]) - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'return-type': - type_name = arg[1] - optional = False - for prop in arg[2:]: - if prop[0] == 'optional': - optional = True - self.ret = ReturnType(type_name, optional) - elif arg[0] == 'caller-owns-return': - self.caller_owns_return = arg[1] in ('t', '#t') - elif arg[0] == 'unblock-threads': - self.unblock_threads = arg[1] in ('t', '#t') - elif arg[0] == 'parameters': - for parg in arg[1:]: - ptype = parg[0] - pname = parg[1] - pdflt = None - pnull = 0 - pdir = None - for farg in parg[2:]: - assert isinstance(farg, tuple) - if farg[0] == 'default': - pdflt = farg[1] - elif farg[0] == 'null-ok': - pnull = 1 - elif farg[0] == 'direction': - pdir = farg[1] - self.params.append(Parameter(ptype, pname, pdflt, pnull, pdir)) - elif arg[0] == 'varargs': - self.varargs = arg[1] in ('t', '#t') - elif arg[0] == 'deprecated': - self.deprecated = arg[1] - else: - sys.stderr.write("Warning: %s argument unsupported.\n" - % (arg[0])) - dump = 1 - if dump: - self.write_defs(sys.stderr) - - if self.caller_owns_return is None and self.ret is not None: - self.guess_return_value_ownership() - - def merge(self, old, parmerge): - self.caller_owns_return = old.caller_owns_return - self.varargs = old.varargs - # here we merge extra parameter flags accross to the new object. - if not parmerge: - self.params = copy.deepcopy(old.params) - return - for i in range(len(self.params)): - ptype, pname, pdflt, pnull = self.params[i] - for p2 in old.params: - if p2[1] == pname: - self.params[i] = (ptype, pname, p2[2], p2[3]) - break - def _write_defs(self, fp=sys.stdout): - if self.of_object != (None, None): - fp.write(' (of-object "' + self.of_object + '")\n') - if self.c_name: - fp.write(' (c-name "' + self.c_name + '")\n') - if self.typecode: - fp.write(' (gtype-id "' + self.typecode + '")\n') - if self.caller_owns_return: - fp.write(' (caller-owns-return #t)\n') - if self.unblock_threads: - fp.write(' (unblock_threads #t)\n') - if self.ret: - fp.write(' (return-type "' + self.ret + '")\n') - if self.deprecated: - fp.write(' (deprecated "' + self.deprecated + '")\n') - if self.params: - fp.write(' (parameters\n') - for ptype, pname, pdflt, pnull in self.params: - fp.write(' \'("' + ptype + '" "' + pname +'"') - if pdflt: fp.write(' (default "' + pdflt + '")') - if pnull: fp.write(' (null-ok)') - fp.write(')\n') - fp.write(' )\n') - if self.varargs: - fp.write(' (varargs #t)\n') - fp.write(')\n\n') - - -class MethodDef(MethodDefBase): - def __init__(self, name, *args): - MethodDefBase.__init__(self, name, *args) - for item in ('c_name', 'of_object'): - if self.__dict__[item] == None: - self.write_defs(sys.stderr) - raise RuntimeError("definition missing required %s" % (item,)) - - def write_defs(self, fp=sys.stdout): - fp.write('(define-method ' + self.name + '\n') - self._write_defs(fp) - -class VirtualDef(MethodDefBase): - def write_defs(self, fp=sys.stdout): - fp.write('(define-virtual ' + self.name + '\n') - self._write_defs(fp) - -class FunctionDef(Definition): - def __init__(self, name, *args): - dump = 0 - self.name = name - self.in_module = None - self.is_constructor_of = None - self.ret = None - self.caller_owns_return = None - self.unblock_threads = None - self.c_name = None - self.typecode = None - self.params = [] # of form (type, name, default, nullok) - self.varargs = 0 - self.deprecated = None - for arg in get_valid_scheme_definitions(args): - if arg[0] == 'in-module': - self.in_module = arg[1] - elif arg[0] == 'docstring': - self.docstring = make_docstring(arg[1:]) - elif arg[0] == 'is-constructor-of': - self.is_constructor_of = arg[1] - elif arg[0] == 'c-name': - self.c_name = arg[1] - elif arg[0] == 'gtype-id': - self.typecode = arg[1] - elif arg[0] == 'return-type': - self.ret = arg[1] - elif arg[0] == 'caller-owns-return': - self.caller_owns_return = arg[1] in ('t', '#t') - elif arg[0] == 'unblock-threads': - self.unblock_threads = arg[1] in ('t', '#t') - elif arg[0] == 'parameters': - for parg in arg[1:]: - ptype = parg[0] - pname = parg[1] - pdflt = None - pnull = 0 - for farg in parg[2:]: - if farg[0] == 'default': - pdflt = farg[1] - elif farg[0] == 'null-ok': - pnull = 1 - self.params.append(Parameter(ptype, pname, pdflt, pnull)) - elif arg[0] == 'properties': - if self.is_constructor_of is None: - print >> sys.stderr, "Warning: (properties ...) "\ - "is only valid for constructors" - for prop in arg[1:]: - pname = prop[0] - optional = False - argname = pname - for farg in prop[1:]: - if farg[0] == 'optional': - optional = True - elif farg[0] == 'argname': - argname = farg[1] - self.params.append(Property(pname, optional, argname)) - elif arg[0] == 'varargs': - self.varargs = arg[1] in ('t', '#t') - elif arg[0] == 'deprecated': - self.deprecated = arg[1] - else: - sys.stderr.write("Warning: %s argument unsupported\n" - % (arg[0],)) - dump = 1 - if dump: - self.write_defs(sys.stderr) - - if self.caller_owns_return is None and self.ret is not None: - self.guess_return_value_ownership() - for item in ('c_name',): - if self.__dict__[item] == None: - self.write_defs(sys.stderr) - raise RuntimeError("definition missing required %s" % (item,)) - - _method_write_defs = MethodDef.__dict__['write_defs'] - - def merge(self, old, parmerge): - self.caller_owns_return = old.caller_owns_return - self.varargs = old.varargs - if not parmerge: - self.params = copy.deepcopy(old.params) - return - # here we merge extra parameter flags accross to the new object. - def merge_param(param): - for old_param in old.params: - if old_param.pname == param.pname: - if isinstance(old_param, Property): - # h2def never scans Property's, therefore if - # we have one it was manually written, so we - # keep it. - return copy.deepcopy(old_param) - else: - param.merge(old_param) - return param - raise RuntimeError("could not find %s in old_parameters %r" % ( - param.pname, [p.pname for p in old.params])) - try: - self.params = map(merge_param, self.params) - except RuntimeError: - # parameter names changed and we can't find a match; it's - # safer to keep the old parameter list untouched. - self.params = copy.deepcopy(old.params) - - if not self.is_constructor_of: - try: - self.is_constructor_of = old.is_constructor_of - except AttributeError: - pass - if isinstance(old, MethodDef): - self.name = old.name - # transmogrify from function into method ... - self.write_defs = self._method_write_defs - self.of_object = old.of_object - del self.params[0] - def write_defs(self, fp=sys.stdout): - fp.write('(define-function ' + self.name + '\n') - if self.in_module: - fp.write(' (in-module "' + self.in_module + '")\n') - if self.is_constructor_of: - fp.write(' (is-constructor-of "' + self.is_constructor_of +'")\n') - if self.c_name: - fp.write(' (c-name "' + self.c_name + '")\n') - if self.typecode: - fp.write(' (gtype-id "' + self.typecode + '")\n') - if self.caller_owns_return: - fp.write(' (caller-owns-return #t)\n') - if self.unblock_threads: - fp.write(' (unblock-threads #t)\n') - if self.ret: - fp.write(' (return-type "' + self.ret + '")\n') - if self.deprecated: - fp.write(' (deprecated "' + self.deprecated + '")\n') - if self.params: - if isinstance(self.params[0], Parameter): - fp.write(' (parameters\n') - for ptype, pname, pdflt, pnull in self.params: - fp.write(' \'("' + ptype + '" "' + pname +'"') - if pdflt: fp.write(' (default "' + pdflt + '")') - if pnull: fp.write(' (null-ok)') - fp.write(')\n') - fp.write(' )\n') - elif isinstance(self.params[0], Property): - fp.write(' (properties\n') - for prop in self.params: - fp.write(' \'("' + prop.pname +'"') - if prop.optional: fp.write(' (optional)') - fp.write(')\n') - fp.write(' )\n') - else: - assert False, "strange parameter list %r" % self.params[0] - if self.varargs: - fp.write(' (varargs #t)\n') - - fp.write(')\n\n') diff --git a/bindings/python/codegen/defsparser.py b/bindings/python/codegen/defsparser.py deleted file mode 100644 index 37ba0a2f9b..0000000000 --- a/bindings/python/codegen/defsparser.py +++ /dev/null @@ -1,153 +0,0 @@ -# -*- Mode: Python; py-indent-offset: 4 -*- -import os, sys -import scmexpr -from definitions import BoxedDef, EnumDef, FlagsDef, FunctionDef, \ - InterfaceDef, MethodDef, ObjectDef, PointerDef, VirtualDef - -include_path = ['.'] - -class IncludeParser(scmexpr.Parser): - """A simple parser that follows include statements automatically""" - def include(self, input_filename): - global include_path - if os.path.isabs(input_filename): - filename = input_filename - # set self.filename to the include name, to handle recursive includes - oldfile = self.filename - self.filename = filename - self.startParsing() - self.filename = oldfile - else: - inc_path = [os.path.dirname(self.filename)] + include_path - for filename in [os.path.join(path_entry, input_filename) - for path_entry in inc_path]: - if not os.path.exists(filename): - continue - # set self.filename to the include name, to handle recursive includes - oldfile = self.filename - self.filename = filename - self.startParsing() - self.filename = oldfile - break - else: - raise IOError("%s not found in include path %s" % (input_filename, inc_path)) - -class DefsParser(IncludeParser): - def __init__(self, arg, defines={}): - IncludeParser.__init__(self, arg) - self.objects = [] - self.interfaces = [] - self.enums = [] # enums and flags - self.boxes = [] # boxed types - self.pointers = [] # pointer types - self.functions = [] # functions and methods - self.virtuals = [] # virtual methods - self.c_name = {} # hash of c names of functions - self.methods = {} # hash of methods of particular objects - self.defines = defines # -Dfoo=bar options, as dictionary - - def define_object(self, *args): - odef = apply(ObjectDef, args) - self.objects.append(odef) - self.c_name[odef.c_name] = odef - def define_interface(self, *args): - idef = apply(InterfaceDef, args) - self.interfaces.append(idef) - self.c_name[idef.c_name] = idef - def define_enum(self, *args): - edef = apply(EnumDef, args) - self.enums.append(edef) - self.c_name[edef.c_name] = edef - def define_flags(self, *args): - fdef = apply(FlagsDef, args) - self.enums.append(fdef) - self.c_name[fdef.c_name] = fdef - def define_boxed(self, *args): - bdef = apply(BoxedDef, args) - self.boxes.append(bdef) - self.c_name[bdef.c_name] = bdef - def define_pointer(self, *args): - pdef = apply(PointerDef, args) - self.pointers.append(pdef) - self.c_name[pdef.c_name] = pdef - def define_function(self, *args): - fdef = apply(FunctionDef, args) - self.functions.append(fdef) - self.c_name[fdef.c_name] = fdef - def define_method(self, *args): - mdef = apply(MethodDef, args) - self.functions.append(mdef) - self.c_name[mdef.c_name] = mdef - def define_virtual(self, *args): - vdef = apply(VirtualDef, args) - self.virtuals.append(vdef) - def merge(self, old, parmerge): - for obj in self.objects: - if old.c_name.has_key(obj.c_name): - obj.merge(old.c_name[obj.c_name]) - for f in self.functions: - if old.c_name.has_key(f.c_name): - f.merge(old.c_name[f.c_name], parmerge) - - def printMissing(self, old): - for obj in self.objects: - if not old.c_name.has_key(obj.c_name): - obj.write_defs() - for f in self.functions: - if not old.c_name.has_key(f.c_name): - f.write_defs() - - def write_defs(self, fp=sys.stdout): - for obj in self.objects: - obj.write_defs(fp) - for enum in self.enums: - enum.write_defs(fp) - for boxed in self.boxes: - boxed.write_defs(fp) - for pointer in self.pointers: - pointer.write_defs(fp) - for func in self.functions: - func.write_defs(fp) - - def find_object(self, c_name): - for obj in self.objects: - if obj.c_name == c_name: - return obj - else: - raise ValueError('object %r not found' % c_name) - - def find_constructor(self, obj, overrides): - for func in self.functions: - if isinstance(func, FunctionDef) and \ - func.is_constructor_of == obj.c_name and \ - not overrides.is_ignored(func.c_name): - return func - - def find_methods(self, obj): - objname = obj.c_name - return filter(lambda func, on=objname: isinstance(func, MethodDef) and - func.of_object == on, self.functions) - - def find_virtuals(self, obj): - objname = obj.c_name - retval = filter(lambda func, on=objname: isinstance(func, VirtualDef) and - func.of_object == on, self.virtuals) - return retval - - def find_functions(self): - return filter(lambda func: isinstance(func, FunctionDef) and - not func.is_constructor_of, self.functions) - - def ifdef(self, *args): - if args[0] in self.defines: - for arg in args[1:]: - #print >> sys.stderr, "-----> Handling conditional definition (%s): %s" % (args[0], arg) - self.handle(arg) - else: - pass - #print >> sys.stderr, "-----> Conditional %s is not true" % (args[0],) - - def ifndef(self, *args): - if args[0] not in self.defines: - for arg in args[1:]: - self.handle(arg) diff --git a/bindings/python/codegen/docextract.py b/bindings/python/codegen/docextract.py deleted file mode 100644 index 13beeffbd6..0000000000 --- a/bindings/python/codegen/docextract.py +++ /dev/null @@ -1,461 +0,0 @@ -# -*- Mode: Python; py-indent-offset: 4 -*- -'''Simple module for extracting GNOME style doc comments from C -sources, so I can use them for other purposes.''' - -import sys, os, string, re - -# Used to tell if the "Since: ..." portion of the gtkdoc function description -# should be omitted. This is useful for some C++ modules such as gstreamermm -# that wrap C API which is still unstable and including this information would -# not be useful. -# This variable is modified from docextract_to_xml based on the --no-since -# option being specified. -no_since = False - -__all__ = ['extract'] - -class GtkDoc: - def __init__(self): - self.name = None - self.block_type = '' # The block type ('function', 'signal', 'property') - self.params = [] - self.annotations = [] - self.description = '' - self.ret = ('', []) # (return, annotations) - def set_name(self, name): - self.name = name - def set_type(self, block_type): - self.block_type = block_type - def get_type(self): - return self.block_type - def add_param(self, name, description, annotations=[]): - if name == '...': - name = 'Varargs' - self.params.append((name, description, annotations)) - def append_to_last_param(self, extra): - self.params[-1] = (self.params[-1][0], self.params[-1][1] + extra, - self.params[-1][2]) - def append_to_named_param(self, name, extra): - for i in range(len(self.params)): - if self.params[i][0] == name: - self.params[i] = (name, self.params[i][1] + extra, - self.params[i][2]) - return - # fall through to adding extra parameter ... - self.add_param(name, extra) - def add_annotation(self, annotation): - self.annotations.append(annotation) - def get_annotations(self): - return self.annotations - def append_to_description(self, extra): - self.description = self.description + extra - def get_description(self): - return self.description - def add_return(self, first_line, annotations=[]): - self.ret = (first_line, annotations) - def append_to_return(self, extra): - self.ret = (self.ret[0] + extra, self.ret[1]) - -comment_start_pattern = re.compile(r'^\s*/\*\*\s') -comment_end_pattern = re.compile(r'^\s*\*+/') -comment_line_lead_pattern = re.compile(r'^\s*\*\s*') -comment_empty_line_pattern = re.compile(r'^\s*\**\s*$') -function_name_pattern = re.compile(r'^([a-z]\w*)\s*:?(\s*\(.*\)\s*){0,2}\s*$') -signal_name_pattern = re.compile(r'^([A-Z]\w+::[a-z0-9-]+)\s*:?(\s*\(.*\)\s*){0,2}\s*$') -property_name_pattern = re.compile(r'^([A-Z]\w+:[a-z0-9-]+)\s*:?(\s*\(.*\)\s*){0,2}\s*$') -return_pattern = re.compile(r'^@?(returns:|return\s+value:)(.*\n?)$', re.IGNORECASE) -deprecated_pattern = re.compile(r'^(deprecated\s*:\s*.*\n?)$', re.IGNORECASE) -rename_to_pattern = re.compile(r'^(rename\s+to)\s*:\s*(.*\n?)$', re.IGNORECASE) -param_pattern = re.compile(r'^@(\S+)\s*:(.*\n?)$') -# Used to extract the annotations in the parameter and return descriptions -# extracted using above [param|return]_pattern patterns. -annotations_pattern = re.compile(r'^(?:(\s*\(.*\)\s*)*:)') -# Used to construct the annotation lists. -annotation_lead_pattern = re.compile(r'^\s*\(\s*(.*?)\s*\)\s*') - -# These patterns determine the identifier of the current comment block. They -# are grouped in a list for easy determination of block identifiers (in -# skip_to_identifier). The function_name_pattern should be tested for last -# because it always matches signal and property identifiers. -identifier_patterns = [ signal_name_pattern, property_name_pattern, function_name_pattern ] - -# This pattern is to match return sections that forget to have a colon (':') -# after the initial 'Return' phrase. It is not included by default in the list -# of final sections below because a lot of function descriptions begin with -# 'Returns ...' and the process_description() function would stop right at that -# first line, thinking it is a return section. -no_colon_return_pattern = re.compile(r'^@?(returns|return\s+value)\s*(.*\n?)$', re.IGNORECASE) -since_pattern = re.compile(r'^(since\s*:\s*.*\n?)$', re.IGNORECASE) - -# These patterns normally will be encountered after the description. Knowing -# the order of their appearance is difficult so this list is used to test when -# one begins and the other ends when processing the rest of the sections after -# the description. -final_section_patterns = [ return_pattern, since_pattern, deprecated_pattern, rename_to_pattern ] - -def parse_file(fp, doc_dict): - line = fp.readline() - while line: - cur_doc = GtkDoc() - line = skip_to_comment_block(fp, line) - line = skip_to_identifier(fp, line, cur_doc) - # See if the identifier is found (stored in the current GtkDoc by - # skip_to_identifier). If so, continue reading the rest of the comment - # block. - if cur_doc.name: - line = process_params(fp, line, cur_doc) - line = process_description(fp, line, cur_doc) - line = process_final_sections(fp, line, cur_doc) - # Add the current doc block to the dictionary of doc blocks. - doc_dict[cur_doc.name] = cur_doc - -# Given a list of annotations as string of the form -# '(annotation1) (annotation2) ...' return a list of annotations of the form -# [ (name1, value1), (name2, value2) ... ]. Not all annotations have values so -# the values in the list of tuples could be empty (''). -def get_annotation_list(annotations): - annotation_list = [] - while annotations: - match = annotation_lead_pattern.match(annotations) - if match: - annotation_contents = match.group(1) - name, split, value = annotation_contents.strip().partition(' ') - annotation_list.append((name, value)) - # Remove first occurrence to continue processing. - annotations = annotation_lead_pattern.sub('', annotations) - else: - break - return annotation_list - -# Given a currently read line, test that line and continue reading until the -# beginning of a comment block is found or eof is reached. Return the last -# read line. -def skip_to_comment_block(fp, line): - while line: - if comment_start_pattern.match(line): - break - line = fp.readline() - return line - -# Given the current line in a comment block, continue skipping lines until a -# non-blank line in the comment block is found or until the end of the block -# (or eof) is reached. Returns the line where reading stopped. -def skip_to_nonblank(fp, line): - while line: - if not comment_empty_line_pattern.match(line): - break - line = fp.readline() - # Stop processing if eof or end of comment block is reached. - if not line or comment_end_pattern.match(line): - break - return line - -# Given the first line of a comment block (the '/**'), see if the next -# non-blank line is the identifier of the comment block. Stop processing if -# the end of the block or eof is reached. Store the identifier (if there is -# one) and its type ('function', 'signal' or 'property') in the given GtkDoc. -# Return the line where the identifier is found or the line that stops the -# processing (if eof or the end of the comment block is found first). -def skip_to_identifier(fp, line, cur_doc): - # Skip the initial comment block line ('/**') if not eof. - if line: line = fp.readline() - - # Now skip empty lines. - line = skip_to_nonblank(fp, line) - - # See if the first non-blank line is the identifier. - if line and not comment_end_pattern.match(line): - # Remove the initial ' * ' in comment block line and see if there is an - # identifier. - line = comment_line_lead_pattern.sub('', line) - for pattern in identifier_patterns: - match = pattern.match(line) - if match: - # Set the GtkDoc name. - cur_doc.set_name(match.group(1)) - # Get annotations and add them to the GtkDoc. - annotations = get_annotation_list(match.group(2)) - for annotation in annotations: - cur_doc.add_annotation(annotation) - # Set the GtkDoc type. - if pattern == signal_name_pattern: - cur_doc.set_type('signal') - elif pattern == property_name_pattern: - cur_doc.set_type('property') - elif pattern == function_name_pattern: - cur_doc.set_type('function') - return line - return line - -# Given a currently read line (presumably the identifier line), read the next -# lines, testing to see if the lines are part of parameter descriptions. If -# so, store the parameter descriptions in the given doc block. Stop on eof and -# return the last line that stops the processing. -def process_params(fp, line, cur_doc): - # Skip the identifier line if not eof. Also skip any blank lines in the - # comment block. Return if eof or the end of the comment block are - # encountered. - if line: line = fp.readline() - line = skip_to_nonblank(fp, line) - if not line or comment_end_pattern.match(line): - return line - - # Remove initial ' * ' in first non-empty comment block line. - line = comment_line_lead_pattern.sub('', line) - - # Now process possible parameters as long as no eof or the end of the - # param section is not reached (which could be triggered by anything that - # doesn't match a '@param:..." line, even the end of the comment block). - match = param_pattern.match(line) - while line and match: - description = match.group(2) - - # First extract the annotations from the description and save them. - annotations = [] - annotation_match = annotations_pattern.match(description) - if annotation_match: - annotations = get_annotation_list(annotation_match.group(1)) - # Remove the annotations from the description - description = annotations_pattern.sub('', description) - - # Default to appending lines to current parameter. - append_func = cur_doc.append_to_last_param - - # See if the return has been included as part of the parameter - # section and make sure that lines are added to the GtkDoc return if - # so. - if match.group(1).lower() == "returns": - cur_doc.add_return(description, annotations) - append_func = cur_doc.append_to_return - # If not, just add it as a regular parameter. - else: - cur_doc.add_param(match.group(1), description, annotations) - - # Now read lines and append them until next parameter, beginning of - # description (an empty line), the end of the comment block or eof. - line = fp.readline() - while line: - # Stop processing if end of comment block or a blank comment line - # is encountered. - if comment_empty_line_pattern.match(line) or \ - comment_end_pattern.match(line): - break - - # Remove initial ' * ' in comment block line. - line = comment_line_lead_pattern.sub('', line) - - # Break from current param processing if a new one is - # encountered. - if param_pattern.match(line): break; - - # Otherwise, just append the current line and get the next line. - append_func(line) - line = fp.readline() - - # Re-evaluate match for while condition - match = param_pattern.match(line) - - # End by returning the current line. - return line - -# Having processed parameters, read the following lines into the description of -# the current doc block until the end of the comment block, the end of file or -# a return section is encountered. -def process_description(fp, line, cur_doc): - # First skip empty lines returning on eof or end of comment block. - line = skip_to_nonblank(fp, line) - if not line or comment_end_pattern.match(line): - return line - - # Remove initial ' * ' in non-empty comment block line. - line = comment_line_lead_pattern.sub('', line) - - # Also remove possible 'Description:' prefix. - if line[:12] == 'Description:': line = line[12:] - - # Used to tell if the previous line was blank and a return section - # uncommonly marked with 'Returns ...' instead of 'Returns: ...' has - # started (assume it is non-empty to begin with). - prev_line = 'non-empty' - - # Now read lines until a new section (like a return or a since section) is - # encountered. - while line: - # See if the description section has ended (if the line begins with - # 'Returns ...' and the previous line was empty -- this loop replaces - # empty lines with a newline). - if no_colon_return_pattern.match(line) and prev_line == '\n': - return line - # Or if one of the patterns of the final sections match - for pattern in final_section_patterns: - if pattern.match(line): - return line - - # If not, append lines to description in the doc comment block. - cur_doc.append_to_description(line) - - prev_line = line - line = fp.readline() - - # Stop processing on eof or at the end of comment block. - if not line or comment_end_pattern.match(line): - return line - - # Remove initial ' * ' in line so that the text can be appended to the - # description of the comment block and make sure that if the line is - # empty it be interpreted as a newline. - line = comment_line_lead_pattern.sub('', line) - if not line: line = '\n' - -# Given the line that ended the description (the first line of one of the final -# sections) process the final sections ('Returns:', 'Since:', etc.) until the -# end of the comment block or eof. Return the line that ends the processing. -def process_final_sections(fp, line, cur_doc): - while line and not comment_end_pattern.match(line): - # Remove leading ' * ' from current non-empty comment line. - line = comment_line_lead_pattern.sub('', line) - # Temporarily append the no colon return pattern to the final section - # patterns now that the description has been processed. It will be - # removed after the for loop below executes so that future descriptions - # that begin with 'Returns ...' are not interpreted as a return - # section. - final_section_patterns.append(no_colon_return_pattern) - for pattern in final_section_patterns: - match = pattern.match(line) - if match: - if pattern == return_pattern or \ - pattern == no_colon_return_pattern: - # Dealing with a 'Returns:' so first extract the - # annotations from the description and save them. - description = match.group(2) - annotations = [] - annotation_match = \ - annotations_pattern.match(description) - if annotation_match: - annotations = \ - get_annotation_list(annotation_match.group(1)) - # Remove the annotations from the description - description = annotations_pattern.sub('', description) - - # Now add the return. - cur_doc.add_return(description, annotations) - # In case more lines need to be appended. - append_func = cur_doc.append_to_return - elif pattern == rename_to_pattern: - # Dealing with a 'Rename to:' section (GObjectIntrospection - # annotation) so no further lines will be appended but this - # single one (and only to the annotations). - append_func = None - cur_doc.add_annotation((match.group(1), - match.group(2))) - else: - # For all others ('Since:' and 'Deprecated:') just append - # the line to the description for now. - # But if --no-since is specified, don't append it. - if no_since and pattern == since_pattern: - pass - else: - cur_doc.append_to_description(line) - - # In case more lines need to be appended. - append_func = cur_doc.append_to_description - - # Stop final section pattern matching for loop since a match - # has already been found. - break - - # Remove the no colon return pattern (which was temporarily added in - # the just executed loop) from the list of final section patterns. - final_section_patterns.pop() - - line = fp.readline() - - # Now continue appending lines to current section until a new one is - # found or an eof or the end of the comment block is encountered. - finished = False - while not finished and line and \ - not comment_end_pattern.match(line): - # Remove leading ' * ' from line and make sure that if it is empty, - # it be interpreted as a newline. - line = comment_line_lead_pattern.sub('', line) - if not line: line = '\n' - - for pattern in final_section_patterns: - if pattern.match(line): - finished = True - break - - # Break out of loop if a new section is found (determined in above - # inner loop). - if finished: break - - # Now it's safe to append line. - if append_func: append_func(line) - - # Get the next line to continue processing. - line = fp.readline() - - return line - -def parse_dir(dir, doc_dict): - for file in os.listdir(dir): - if file in ('.', '..'): continue - path = os.path.join(dir, file) - if os.path.isdir(path): - parse_dir(path, doc_dict) - if len(file) > 2 and file[-2:] == '.c': - sys.stderr.write("Processing " + path + '\n') - parse_file(open(path, 'r'), doc_dict) - -def extract(dirs, doc_dict=None): - if not doc_dict: doc_dict = {} - for dir in dirs: - parse_dir(dir, doc_dict) - return doc_dict - -tmpl_section_pattern = re.compile(r'^$') -def parse_tmpl(fp, doc_dict): - cur_doc = None - - line = fp.readline() - while line: - match = tmpl_section_pattern.match(line) - if match: - cur_doc = None # new input shouldn't affect the old doc dict - sect_type = match.group(1) - sect_name = match.group(2) - - if sect_type == 'FUNCTION': - cur_doc = doc_dict.get(sect_name) - if not cur_doc: - cur_doc = GtkDoc() - cur_doc.set_name(sect_name) - doc_dict[sect_name] = cur_doc - elif line == '\n': - cur_doc = None # don't worry about unused params. - elif cur_doc: - if line[:10] == '@Returns: ': - if string.strip(line[10:]): - cur_doc.append_to_return(line[10:]) - elif line[0] == '@': - pos = string.find(line, ':') - if pos >= 0: - cur_doc.append_to_named_param(line[1:pos], line[pos+1:]) - else: - cur_doc.append_to_description(line) - else: - cur_doc.append_to_description(line) - - line = fp.readline() - -def extract_tmpl(dirs, doc_dict=None): - if not doc_dict: doc_dict = {} - for dir in dirs: - for file in os.listdir(dir): - if file in ('.', '..'): continue - path = os.path.join(dir, file) - if os.path.isdir(path): - continue - if len(file) > 2 and file[-2:] == '.sgml': - parse_tmpl(open(path, 'r'), doc_dict) - return doc_dict diff --git a/bindings/python/codegen/docgen.py b/bindings/python/codegen/docgen.py deleted file mode 100755 index b9e2f67da0..0000000000 --- a/bindings/python/codegen/docgen.py +++ /dev/null @@ -1,766 +0,0 @@ -#!/usr/bin/env python -import getopt -import os -import re -import sys - -import definitions -import defsparser -import docextract -import override - - -class Node: - - def __init__(self, name, interfaces=[]): - self.name = name - self.interfaces = interfaces - self.subclasses = [] - - def add_child(self, node): - self.subclasses.append(node) - - -def build_object_tree(parser): - # reorder objects so that parent classes come first ... - objects = parser.objects[:] - pos = 0 - while pos < len(objects): - parent = objects[pos].parent - for i in range(pos+1, len(objects)): - if objects[i].c_name == parent: - objects.insert(i+1, objects[pos]) - del objects[pos] - break - else: - pos = pos + 1 - - root = Node(None) - nodes = {None: root} - for obj_def in objects: - parent_name = obj_def.parent - if parent_name == 'GObject': - parent_name = None - parent_node = nodes[parent_name] - node = Node(obj_def.c_name, obj_def.implements) - parent_node.add_child(node) - nodes[node.name] = node - - if parser.interfaces: - interfaces = Node('gobject.GInterface') - root.add_child(interfaces) - nodes[interfaces.name] = interfaces - for obj_def in parser.interfaces: - node = Node(obj_def.c_name) - interfaces.add_child(node) - nodes[node.name] = node - - if parser.boxes: - boxed = Node('gobject.GBoxed') - root.add_child(boxed) - nodes[boxed.name] = boxed - for obj_def in parser.boxes: - node = Node(obj_def.c_name) - boxed.add_child(node) - nodes[node.name] = node - - if parser.pointers: - pointers = Node('gobject.GPointer') - root.add_child(pointers) - nodes[pointers.name] = pointers - for obj_def in parser.pointers: - node = Node(obj_def.c_name) - pointers.add_child(node) - nodes[node.name] = node - - return root - - -class DocWriter: - - def __init__(self): - self._fp = None - # parse the defs file - self.parser = defsparser.DefsParser(()) - self.overrides = override.Overrides() - self.classmap = {} - self.docs = {} - - def add_sourcedirs(self, source_dirs): - self.docs = docextract.extract(source_dirs, self.docs) - - def add_tmpldirs(self, tmpl_dirs): - self.docs = docextract.extract_tmpl(tmpl_dirs, self.docs) - - def add_docs(self, defs_file, overrides_file, module_name): - '''parse information about a given defs file''' - self.parser.filename = defs_file - self.parser.startParsing(defs_file) - if overrides_file: - self.overrides.handle_file(overrides_file) - - for obj in (self.parser.objects + self.parser.interfaces + - self.parser.boxes + self.parser.pointers): - if not obj.c_name in self.classmap: - self.classmap[obj.c_name] = '%s.%s' % ( - module_name, obj.name) - - def pyname(self, name): - return self.classmap.get(name, name) - - def _compare(self, obja, objb): - return cmp(self.pyname(obja.c_name), self.pyname(objb.c_name)) - - def output_docs(self, output_prefix): - files = {} - - # class hierarchy - hierarchy = build_object_tree(self.parser) - filename = self.create_filename('hierarchy', output_prefix) - self._fp = open(filename, 'w') - self.write_full_hierarchy(hierarchy) - self._fp.close() - - obj_defs = (self.parser.objects + self.parser.interfaces + - self.parser.boxes + self.parser.pointers) - obj_defs.sort(self._compare) - - for obj_def in obj_defs: - filename = self.create_filename(obj_def.c_name, output_prefix) - self._fp = open(filename, 'w') - if isinstance(obj_def, definitions.ObjectDef): - self.output_object_docs(obj_def) - elif isinstance(obj_def, definitions.InterfaceDef): - self.output_interface_docs(obj_def) - elif isinstance(obj_def, definitions.BoxedDef): - self.output_boxed_docs(obj_def) - elif isinstance(obj_def, definitions.PointerDef): - self.output_boxed_docs(obj_def) - self._fp.close() - files[os.path.basename(filename)] = obj_def - - if not files: - return - - output_filename = self.create_toc_filename(output_prefix) - self._fp = open(output_filename, 'w') - self.output_toc(files) - self._fp.close() - - def output_object_docs(self, obj_def): - self.write_class_header(obj_def.c_name) - - self.write_heading('Synopsis') - self.write_synopsis(obj_def) - self.close_section() - - # construct the inheritence hierarchy ... - ancestry = [(obj_def.c_name, obj_def.implements)] - try: - parent = obj_def.parent - while parent != None: - if parent == 'GObject': - ancestry.append(('GObject', [])) - parent = None - else: - parent_def = self.parser.find_object(parent) - ancestry.append((parent_def.c_name, parent_def.implements)) - parent = parent_def.parent - except ValueError: - pass - ancestry.reverse() - self.write_heading('Ancestry') - self.write_hierarchy(obj_def.c_name, ancestry) - self.close_section() - - constructor = self.parser.find_constructor(obj_def, self.overrides) - if constructor: - self.write_heading('Constructor') - self.write_constructor(constructor, - self.docs.get(constructor.c_name, None)) - self.close_section() - - methods = self.parser.find_methods(obj_def) - methods = filter(lambda meth, self=self: - not self.overrides.is_ignored(meth.c_name), methods) - if methods: - self.write_heading('Methods') - for method in methods: - self.write_method(method, self.docs.get(method.c_name, None)) - self.close_section() - - self.write_class_footer(obj_def.c_name) - - def get_methods_for_object(self, obj_def): - methods = [] - for method in self.parser.find_methods(obj_def): - if not self.overrides.is_ignored(method.c_name): - methods.append(method) - return methods - - def output_interface_docs(self, int_def): - self.write_class_header(int_def.c_name) - - self.write_heading('Synopsis') - self.write_synopsis(int_def) - self.close_section() - - methods = self.get_methods_for_object(int_def) - if methods: - self.write_heading('Methods') - for method in methods: - self.write_method(method, self.docs.get(method.c_name, None)) - self.close_section() - self.write_class_footer(int_def.c_name) - - def output_boxed_docs(self, box_def): - self.write_class_header(box_def.c_name) - - self.write_heading('Synopsis') - self.write_synopsis(box_def) - self.close_section() - - constructor = self.parser.find_constructor(box_def, self.overrides) - if constructor: - self.write_heading('Constructor') - self.write_constructor(constructor, - self.docs.get(constructor.c_name, None)) - self.close_section() - - methods = self.get_methods_for_object(box_def) - if methods: - self.write_heading('Methods') - for method in methods: - self.write_method(method, self.docs.get(method.c_name, None)) - self.close_section() - - self.write_class_footer(box_def.c_name) - - def output_toc(self, files): - self._fp.write('TOC\n\n') - for filename in sorted(files): - obj_def = files[filename] - self._fp.write(obj_def.c_name + ' - ' + filename + '\n') - - # override the following to create a more complex output format - - def create_filename(self, obj_name, output_prefix): - '''Create output filename for this particular object''' - return output_prefix + '-' + obj_name.lower() + '.txt' - - def create_toc_filename(self, output_prefix): - return self.create_filename(self, 'docs', output_prefix) - - def write_full_hierarchy(self, hierarchy): - - def handle_node(node, indent=''): - for child in node.subclasses: - self._fp.write(indent + node.name) - if node.interfaces: - self._fp.write(' (implements ') - self._fp.write(', '.join(node.interfaces)) - self._fp.write(')\n') - else: - self._fp.write('\n') - handle_node(child, indent + ' ') - handle_node(hierarchy) - - def serialize_params(self, func_def): - params = [] - for param in func_def.params: - params.append(param[1]) - return ', '.join(params) - - # these need to handle default args ... - - def create_constructor_prototype(self, func_def): - return '%s(%s)' % (func_def.is_constructor_of, - self.serialize_params(func_def)) - - def create_function_prototype(self, func_def): - return '%s(%s)' % (func_def.name, - self.serialize_params(func_def)) - - def create_method_prototype(self, meth_def): - return '%s.%s(%s)' % (meth_def.of_object, - meth_def.name, - self.serialize_params(meth_def)) - - def write_class_header(self, obj_name): - self._fp.write('Class %s\n' % obj_name) - self._fp.write('======%s\n\n' % ('=' * len(obj_name))) - - def write_class_footer(self, obj_name): - pass - - def write_heading(self, text): - self._fp.write('\n' + text + '\n' + ('-' * len(text)) + '\n') - - def close_section(self): - pass - - def write_synopsis(self, obj_def): - self._fp.write('class %s' % obj_def.c_name) - if isinstance(obj_def, definitions.ObjectDef): - bases = [] - if obj_def.parent: - bases.append(obj_def.parent) - bases = bases = obj_def.implements - if bases: - self._fp.write('(%s)' % ', '.join(bases, )) - self._fp.write(':\n') - - constructor = self.parser.find_constructor(obj_def, self.overrides) - if constructor: - prototype = self.create_constructor_prototype(constructor) - self._fp.write(' def %s\n' % prototype) - - for method in self.get_methods_for_object(obj_def): - prototype = self.create_method_prototype(method) - self._fp.write(' def %s\n' % prototype) - - def write_hierarchy(self, obj_name, ancestry): - indent = '' - for name, interfaces in ancestry: - self._fp.write(indent + '+-- ' + name) - if interfaces: - self._fp.write(' (implements ') - self._fp.write(', '.join(interfaces)) - self._fp.write(')\n') - else: - self._fp.write('\n') - indent = indent + ' ' - self._fp.write('\n') - - def write_constructor(self, func_def, func_doc): - prototype = self.create_constructor_prototype(func_def) - self._fp.write(prototype + '\n\n') - for type, name, dflt, null in func_def.params: - self.write_parameter(name, func_doc) - self.write_return_value(func_def, func_doc) - if func_doc and func_doc.description: - self._fp.write(func_doc.description) - self._fp.write('\n\n\n') - - def write_method(self, meth_def, func_doc): - prototype = self.create_method_prototype(meth_def) - self._fp.write(prototype + '\n\n') - for type, name, dflt, null in meth_def.params: - self.write_parameter(name, func_doc) - self.write_return_value(meth_def, func_doc) - if func_doc and func_doc.description: - self._fp.write('\n') - self._fp.write(func_doc.description) - self._fp.write('\n\n') - - def write_parameter(self, param_name, func_doc): - if func_doc: - descr = func_doc.get_param_description(param_name) - else: - descr = 'a ' + type - self._fp.write(' ' + param_name + ': ' + descr + '\n') - - def write_return_value(self, meth_def, func_doc): - if meth_def.ret and meth_def.ret != 'none': - if func_doc and func_doc.ret: - descr = func_doc.ret - else: - descr = 'a ' + meth_def.ret - self._fp.write(' Returns: ' + descr + '\n') - -CLASS_HEADER_TEMPLATE = """ - - %(name)s - 3 - %(miscinfo)s - - - - %(name)s - - -""" -VARIABLE_TEMPLATE = """ - %(parameter)s : - %(description)s - -""" - -DOCBOOK_HEADER = """ - -""" - - -class DocbookDocWriter(DocWriter): - - def __init__(self): - DocWriter.__init__(self) - - self._function_pat = re.compile(r'(\w+)\s*\(\)') - self._parameter_pat = re.compile(r'\@(\w+)') - self._constant_pat = re.compile(r'\%(-?\w+)') - self._symbol_pat = re.compile(r'#([\w-]+)') - - self._transtable = ['-'] * 256 - # make string -> reference translation func - for digit in '0123456789': - self._transtable[ord(digit)] = digit - - for letter in 'abcdefghijklmnopqrstuvwxyz': - self._transtable[ord(letter)] = letter - self._transtable[ord(letter.upper())] = letter - self._transtable = ''.join(self._transtable) - - def create_filename(self, obj_name, output_prefix): - '''Create output filename for this particular object''' - stem = output_prefix + '-' + obj_name.lower() - return stem + '.xml' - - def create_toc_filename(self, output_prefix): - return self.create_filename('classes', output_prefix) - - def make_class_ref(self, obj_name): - return 'class-' + obj_name.translate(self._transtable) - - def make_method_ref(self, meth_def): - return 'method-%s--%s' % ( - meth_def.of_object.translate(self._transtable), - meth_def.name.translate(self._transtable)) - - def _format_function(self, match): - info = self.parser.c_name.get(match.group(1), None) - if info: - if isinstance(info, defsparser.FunctionDef): - return self._format_funcdef(info) - if isinstance(info, defsparser.MethodDef): - return self._format_method(info) - - # fall through through - return '%s()' % (match.group(1), ) - - def _format_funcdef(self, info): - if info.is_constructor_of is not None: - # should have a link here - return '%s()' % ( - self.pyname(info.is_constructor_of), ) - else: - return '%s()' % (info.name, ) - - def _format_param(self, match): - return '%s' % (match.group(1), ) - - def _format_const(self, match): - return '%s' % (match.group(1), ) - - def _format_method(self, info): - return ('' - '%s.%s' - '') % (self.make_method_ref(info), - self.pyname(info.of_object), - info.name) - - def _format_object(self, info): - return ('' - '%s' - '') % (self.make_class_ref(info.c_name), - self.pyname(info.c_name)) - - def _format_symbol(self, match): - info = self.parser.c_name.get(match.group(1), None) - if info: - if isinstance(info, defsparser.FunctionDef): - return self._format_funcdef(info) - elif isinstance(info, defsparser.MethodDef): - return self._format_method(info) - elif isinstance(info, (defsparser.ObjectDef, - defsparser.InterfaceDef, - defsparser.BoxedDef, - defsparser.PointerDef)): - return self._format_object(info) - - # fall through through - return '%s' % (match.group(1), ) - - def reformat_text(self, text, singleline=0): - # replace special strings ... - text = self._function_pat.sub(self._format_function, text) - text = self._parameter_pat.sub(self._format_param, text) - text = self._constant_pat.sub(self._format_const, text) - text = self._symbol_pat.sub(self._format_symbol, text) - - # don't bother with expansion for single line text. - if singleline: - return text - - lines = text.strip().split('\n') - for index in range(len(lines)): - if lines[index].strip() == '': - lines[index] = '\n' - continue - return '%s' % ('\n'.join(lines), ) - - # write out hierarchy - - def write_full_hierarchy(self, hierarchy): - - def handle_node(node, indent=''): - if node.name: - self._fp.write('%s%s' % - (indent, self.make_class_ref(node.name), - self.pyname(node.name))) - if node.interfaces: - self._fp.write(' (implements ') - for i in range(len(node.interfaces)): - self._fp.write('%s' % - (self.make_class_ref(node.interfaces[i]), - self.pyname(node.interfaces[i]))) - if i != len(node.interfaces) - 1: - self._fp.write(', ') - self._fp.write(')\n') - else: - self._fp.write('\n') - - indent = indent + ' ' - node.subclasses.sort(lambda a, b: - cmp(self.pyname(a.name), self.pyname(b.name))) - for child in node.subclasses: - handle_node(child, indent) - - self._fp.write(DOCBOOK_HEADER) - self._fp.write('') - handle_node(hierarchy) - self._fp.write('\n') - - # these need to handle default args ... - - def create_constructor_prototype(self, func_def): - xml = ['\n'] - xml.append(' __init__\n') - for type, name, dflt, null in func_def.params: - xml.append(' ') - xml.append(name) - xml.append('') - if dflt: - xml.append('') - xml.append(dflt) - xml.append('') - xml.append('\n') - if not func_def.params: - xml.append(' ') - xml.append(' ') - return ''.join(xml) - - def create_function_prototype(self, func_def): - xml = ['\n \n'] - xml.append(' ') - xml.append(func_def.name) - xml.append('\n') - for type, name, dflt, null in func_def.params: - xml.append(' ') - xml.append(name) - xml.append('') - if dflt: - xml.append('') - xml.append(dflt) - xml.append('') - xml.append('\n') - if not func_def.params: - xml.append(' \n ') - return ''.join(xml) - - def create_method_prototype(self, meth_def, addlink=0): - xml = ['\n'] - xml.append(' ') - if addlink: - xml.append('' % self.make_method_ref(meth_def)) - xml.append(self.pyname(meth_def.name)) - if addlink: - xml.append('') - xml.append('\n') - for type, name, dflt, null in meth_def.params: - xml.append(' ') - xml.append(name) - xml.append('') - if dflt: - xml.append('') - xml.append(dflt) - xml.append('') - xml.append('\n') - if not meth_def.params: - xml.append(' ') - xml.append(' ') - return ''.join(xml) - - def write_class_header(self, obj_name): - self._fp.write(DOCBOOK_HEADER) - self._fp.write(CLASS_HEADER_TEMPLATE % dict( - entryid=self.make_class_ref(obj_name), - name=self.pyname(obj_name), - miscinfo="PyGTK Docs")) - - def write_class_footer(self, obj_name): - self._fp.write('\n') - - def write_heading(self, text): - self._fp.write(' \n') - self._fp.write(' ' + text + '\n\n') - - def close_section(self): - self._fp.write(' \n') - - def write_synopsis(self, obj_def): - self._fp.write('\n') - self._fp.write(' %s\n' - % self.pyname(obj_def.c_name)) - if isinstance(obj_def, definitions.ObjectDef): - if obj_def.parent: - self._fp.write(' %s' - '\n' - % (self.make_class_ref(obj_def.parent), - self.pyname(obj_def.parent))) - for base in obj_def.implements: - self._fp.write(' %s' - '\n' - % (self.make_class_ref(base), self.pyname(base))) - elif isinstance(obj_def, definitions.InterfaceDef): - self._fp.write(' gobject.GInterface' - '\n') - elif isinstance(obj_def, definitions.BoxedDef): - self._fp.write(' gobject.GBoxed' - '\n') - elif isinstance(obj_def, definitions.PointerDef): - self._fp.write(' gobject.GPointer' - '\n') - - constructor = self.parser.find_constructor(obj_def, self.overrides) - if constructor: - self._fp.write( - '%s\n' % self.create_constructor_prototype(constructor)) - for method in self.get_methods_for_object(obj_def): - self._fp.write( - '%s\n' % self.create_method_prototype(method, addlink=1)) - self._fp.write('\n\n') - - def write_hierarchy(self, obj_name, ancestry): - self._fp.write('') - indent = '' - for name, interfaces in ancestry: - self._fp.write( - '%s+-- %s' % - (indent, self.make_class_ref(name), self.pyname(name))) - if interfaces: - self._fp.write(' (implements ') - for i in range(len(interfaces)): - self._fp.write('%s' % - (self.make_class_ref(interfaces[i]), - self.pyname(interfaces[i]))) - if i != len(interfaces) - 1: - self._fp.write(', ') - self._fp.write(')\n') - else: - self._fp.write('\n') - indent = indent + ' ' - self._fp.write('\n\n') - - def write_params(self, params, ret, func_doc): - if not params and (not ret or ret == 'none'): - return - self._fp.write(' \n') - for type, name, dflt, null in params: - if func_doc: - descr = func_doc.get_param_description(name).strip() - else: - descr = 'a ' + type - self._fp.write(VARIABLE_TEMPLATE % dict( - parameter=name, - description=self.reformat_text(descr, singleline=1))) - if ret and ret != 'none': - if func_doc and func_doc.ret: - descr = func_doc.ret.strip() - else: - descr = 'a ' + ret - self._fp.write(VARIABLE_TEMPLATE % dict( - parameter='Returns', - description=self.reformat_text(descr, singleline=1))) - self._fp.write(' \n') - - def write_constructor(self, func_def, func_doc): - prototype = self.create_constructor_prototype(func_def) - self._fp.write('%s\n' % prototype) - self.write_params(func_def.params, func_def.ret, func_doc) - - if func_doc and func_doc.description: - self._fp.write(self.reformat_text(func_doc.description)) - self._fp.write('\n\n\n') - - def write_method(self, meth_def, func_doc): - self._fp.write(' \n' % ( - self.make_method_ref(meth_def), )) - self._fp.write(' %s.%s\n\n' % ( - self.pyname(meth_def.of_object), - meth_def.name)) - prototype = self.create_method_prototype(meth_def) - self._fp.write('%s\n' % prototype) - self.write_params(meth_def.params, meth_def.ret, func_doc) - if func_doc and func_doc.description: - self._fp.write(self.reformat_text(func_doc.description)) - self._fp.write(' \n\n\n') - - def output_toc(self, files, fp=sys.stdout): - self._fp.write(DOCBOOK_HEADER) - - #self._fp.write('\n') - #self._fp.write(' Class Documentation\n') - #for filename, obj_def in files: - # self._fp.write('&' + - # obj_def.c_name.translate(self._transtable) + ';\n') - #self._fp.write('\n') - - self._fp.write('\n') - self._fp.write(' Class Reference\n') - for filename in sorted(files): - self._fp.write(' \n' % filename) - self._fp.write('\n') - - -def main(args): - try: - opts, args = getopt.getopt(args[1:], "d:s:o:", - ["defs-file=", "override=", "source-dir=", - "output-prefix="]) - except getopt.error, e: - sys.stderr.write('docgen.py: %s\n' % e) - sys.stderr.write( - 'usage: docgen.py -d file.defs [-s /src/dir] [-o output-prefix]\n') - return 1 - - defs_file = None - overrides_file = None - source_dirs = [] - output_prefix = 'docs' - for opt, arg in opts: - if opt in ('-d', '--defs-file'): - defs_file = arg - if opt in ('--override', ): - overrides_file = arg - elif opt in ('-s', '--source-dir'): - source_dirs.append(arg) - elif opt in ('-o', '--output-prefix'): - output_prefix = arg - if len(args) != 0 or not defs_file: - sys.stderr.write( - 'usage: docgen.py -d file.defs [-s /src/dir] [-o output-prefix]\n') - return 1 - - d = DocbookDocWriter() - d.add_sourcedirs(source_dirs) - d.add_docs(defs_file, overrides_file, 'gio') - d.output_docs(output_prefix) - return 0 - - -if __name__ == '__main__': - sys.exit(main(sys.argv)) diff --git a/bindings/python/codegen/h2def.py b/bindings/python/codegen/h2def.py deleted file mode 100755 index 83843705e8..0000000000 --- a/bindings/python/codegen/h2def.py +++ /dev/null @@ -1,637 +0,0 @@ -#!/usr/bin/env python -# -*- Mode: Python; py-indent-offset: 4 -*- -# GPL'ed -# Toby D. Reeves -# -# Modified by James Henstridge to output stuff in -# Havoc's new defs format. Info on this format can be seen at: -# http://mail.gnome.org/archives/gtk-devel-list/2000-January/msg00070.html -# Updated to be PEP-8 compatible and refactored to use OOP -# -# Scan the given public .h files of a GTK module (or module using -# GTK object conventions) and generates a set of scheme defs. -# -# h2def searches through a header file looking for function prototypes and -# generates a scheme style defenition for each prototype. -# Basically the operation of h2def is: -# -# - read each .h file into a buffer which is scrubbed of extraneous data -# - find all object defenitions: -# - find all structures that may represent a GtkObject -# - find all structures that might represent a class -# - find all structures that may represent a GtkObject subclass -# - find all structures that might represent a class/Iface inherited from -# GTypeInterface -# - find all enum defenitions -# - write out the defs -# -# The command line options are: -# -# -s --separate Create separate files for objects and function/method defs -# using the given name as the base name (optional). If this -# is not specified the combined object and function defs -# will be output to sys.stdout. -# -f --defsfilter Extract defs from the given file to filter the output defs -# that is don't output defs that are defined in the -# defsfile. More than one deffile may be specified. -# -m --modulename The prefix to be stripped from the front of function names -# for the given module -# -n --namespace The module or namespace name to be used, for example -# WebKit where h2def is unable to detect the module name -# automatically. it also sets the gtype-id prefix. -# --onlyenums Only produce defs for enums and flags -# --onlyobjdefs Only produce defs for objects -# -v Verbose output -# -# Examples: -# -# python h2def.py /usr/local/include/pango-1.0/pango/*.h >/tmp/pango.defs -# -# - Outputs all defs for the pango module. -# -# python h2def.py -m gdk -s /tmp/gdk-2.10 \ -# -f /usr/tmp/pygtk/gtk/gdk-base.defs \ -# /usr/local/include/gtk-2.0/gdk/*.h \ -# /usr/local/include/gtk-2.0/gdk-pixbuf/*.h -# -# - Outputs the gdk module defs that are not contained in the defs file -# /usr/tmp/pygtk/gtk/gdk-base.defs. Two output files are created: -# /tmp/gdk-2.10-types.defs and /tmp/gdk-2.10.defs. -# -# python h2def.py -n WebKit /usr/incude/webkit-1.0/webkit/*.h \ -# >/tmp/webkit.defs -# -# - Outputs all the defs for webkit module, setting the module name to WebKit -# and the gtype-id prefix to WEBKIT_ which can't be detected automatically. -# - -import getopt -import os -import re -import string -import sys - -import defsparser - -# ------------------ Create typecodes from typenames --------- - -_upperstr_pat1 = re.compile(r'([^A-Z])([A-Z])') -_upperstr_pat2 = re.compile(r'([A-Z][A-Z])([A-Z][0-9a-z])') -_upperstr_pat3 = re.compile(r'^([A-Z])([A-Z])') - -def to_upper_str(name): - """Converts a typename to the equivalent upercase and underscores - name. This is used to form the type conversion macros and enum/flag - name variables""" - name = _upperstr_pat1.sub(r'\1_\2', name) - name = _upperstr_pat2.sub(r'\1_\2', name) - name = _upperstr_pat3.sub(r'\1_\2', name, count=1) - return string.upper(name) - -def typecode(typename, namespace=None): - """create a typecode (eg. GTK_TYPE_WIDGET) from a typename""" - if namespace: - return string.replace(string.upper(namespace) + "_" + to_upper_str(typename[len(namespace):]), '_', '_TYPE_', 1) - - return string.replace(to_upper_str(typename), '_', '_TYPE_', 1) - - -# ------------------ Find object definitions ----------------- -# Strips the comments from buffer -def strip_comments(buf): - parts = [] - lastpos = 0 - while 1: - pos = string.find(buf, '/*', lastpos) - if pos >= 0: - parts.append(buf[lastpos:pos]) - pos = string.find(buf, '*/', pos) - if pos >= 0: - lastpos = pos + 2 - else: - break - else: - parts.append(buf[lastpos:]) - break - return string.join(parts, '') - -# Strips the dll API from buffer, for example WEBKIT_API -def strip_dll_api(buf): - pat = re.compile("[A-Z]*_API ") - buf = pat.sub("", buf) - return buf - -obj_name_pat = "[A-Z][a-z]*[A-Z][A-Za-z0-9]*" - -split_prefix_pat = re.compile('([A-Z]+[a-z]*)([A-Za-z0-9]+)') - -def find_obj_defs(buf, objdefs=[]): - """ - Try to find object definitions in header files. - """ - - # filter out comments from buffer. - buf = strip_comments(buf) - - # filter out dll api - buf = strip_dll_api(buf) - - maybeobjdefs = [] # contains all possible objects from file - - # first find all structures that look like they may represent a GtkObject - pat = re.compile("struct\s+_(" + obj_name_pat + ")\s*{\s*" + - "(" + obj_name_pat + ")\s+", re.MULTILINE) - pos = 0 - while pos < len(buf): - m = pat.search(buf, pos) - if not m: break - maybeobjdefs.append((m.group(1), m.group(2))) - pos = m.end() - - # handle typedef struct { ... } style struct defs. - pat = re.compile("typedef struct\s+[_\w]*\s*{\s*" + - "(" + obj_name_pat + ")\s+[^}]*}\s*" + - "(" + obj_name_pat + ")\s*;", re.MULTILINE) - pos = 0 - while pos < len(buf): - m = pat.search(buf, pos) - if not m: break - maybeobjdefs.append((m.group(2), m.group(1))) - pos = m.end() - - # now find all structures that look like they might represent a class: - pat = re.compile("struct\s+_(" + obj_name_pat + ")Class\s*{\s*" + - "(" + obj_name_pat + ")Class\s+", re.MULTILINE) - pos = 0 - while pos < len(buf): - m = pat.search(buf, pos) - if not m: break - t = (m.group(1), m.group(2)) - # if we find an object structure together with a corresponding - # class structure, then we have probably found a GtkObject subclass. - if t in maybeobjdefs: - objdefs.append(t) - pos = m.end() - - pat = re.compile("typedef struct\s+[_\w]*\s*{\s*" + - "(" + obj_name_pat + ")Class\s+[^}]*}\s*" + - "(" + obj_name_pat + ")Class\s*;", re.MULTILINE) - pos = 0 - while pos < len(buf): - m = pat.search(buf, pos) - if not m: break - t = (m.group(2), m.group(1)) - # if we find an object structure together with a corresponding - # class structure, then we have probably found a GtkObject subclass. - if t in maybeobjdefs: - objdefs.append(t) - pos = m.end() - - # now find all structures that look like they might represent - # a class inherited from GTypeInterface: - pat = re.compile("struct\s+_(" + obj_name_pat + ")Class\s*{\s*" + - "GTypeInterface\s+", re.MULTILINE) - pos = 0 - while pos < len(buf): - m = pat.search(buf, pos) - if not m: break - t = (m.group(1), '') - t2 = (m.group(1)+'Class', 'GTypeInterface') - # if we find an object structure together with a corresponding - # class structure, then we have probably found a GtkObject subclass. - if t2 in maybeobjdefs: - objdefs.append(t) - pos = m.end() - - # now find all structures that look like they might represent - # an Iface inherited from GTypeInterface: - pat = re.compile("struct\s+_(" + obj_name_pat + ")Iface\s*{\s*" + - "GTypeInterface\s+", re.MULTILINE) - pos = 0 - while pos < len(buf): - m = pat.search(buf, pos) - if not m: break - t = (m.group(1), '') - t2 = (m.group(1)+'Iface', 'GTypeInterface') - # if we find an object structure together with a corresponding - # class structure, then we have probably found a GtkObject subclass. - if t2 in maybeobjdefs: - objdefs.append(t) - pos = m.end() - -def sort_obj_defs(objdefs): - objdefs.sort() # not strictly needed, but looks nice - pos = 0 - while pos < len(objdefs): - klass,parent = objdefs[pos] - for i in range(pos+1, len(objdefs)): - # parent below subclass ... reorder - if objdefs[i][0] == parent: - objdefs.insert(i+1, objdefs[pos]) - del objdefs[pos] - break - else: - pos = pos + 1 - return objdefs - -# ------------------ Find enum definitions ----------------- - -def find_enum_defs(buf, enums=[]): - # strip comments - # bulk comments - buf = strip_comments(buf) - - # strip dll api macros - buf = strip_dll_api(buf) - - # strip # directives - pat = re.compile(r"""^[#].*?$""", re.MULTILINE) - buf = pat.sub('', buf) - - buf = re.sub('\n', ' ', buf) - - enum_pat = re.compile(r'enum\s*{([^}]*)}\s*([A-Z][A-Za-z]*)(\s|;)') - splitter = re.compile(r'\s*,\s', re.MULTILINE) - pos = 0 - while pos < len(buf): - m = enum_pat.search(buf, pos) - if not m: break - - name = m.group(2) - vals = m.group(1) - isflags = string.find(vals, '<<') >= 0 - entries = [] - for val in splitter.split(vals): - if not string.strip(val): continue - entries.append(string.split(val)[0]) - if name != 'GdkCursorType': - enums.append((name, isflags, entries)) - - pos = m.end() - -# ------------------ Find function definitions ----------------- - -def clean_func(buf): - """ - Ideally would make buf have a single prototype on each line. - Actually just cuts out a good deal of junk, but leaves lines - where a regex can figure prototypes out. - """ - # bulk comments - buf = strip_comments(buf) - - # dll api - buf = strip_dll_api(buf) - - # compact continued lines - pat = re.compile(r"""\\\n""", re.MULTILINE) - buf = pat.sub('', buf) - - # Preprocess directives - pat = re.compile(r"""^[#].*?$""", re.MULTILINE) - buf = pat.sub('', buf) - - #typedefs, stucts, and enums - pat = re.compile(r"""^(typedef|struct|enum)(\s|.|\n)*?;\s*""", - re.MULTILINE) - buf = pat.sub('', buf) - - #strip DECLS macros - pat = re.compile(r"""G_BEGIN_DECLS|BEGIN_LIBGTOP_DECLS""", re.MULTILINE) - buf = pat.sub('', buf) - - #extern "C" - pat = re.compile(r"""^\s*(extern)\s+\"C\"\s+{""", re.MULTILINE) - buf = pat.sub('', buf) - - #multiple whitespace - pat = re.compile(r"""\s+""", re.MULTILINE) - buf = pat.sub(' ', buf) - - #clean up line ends - pat = re.compile(r""";\s*""", re.MULTILINE) - buf = pat.sub('\n', buf) - buf = buf.lstrip() - - #associate *, &, and [] with type instead of variable - #pat = re.compile(r'\s+([*|&]+)\s*(\w+)') - pat = re.compile(r' \s* ([*|&]+) \s* (\w+)', re.VERBOSE) - buf = pat.sub(r'\1 \2', buf) - pat = re.compile(r'\s+ (\w+) \[ \s* \]', re.VERBOSE) - buf = pat.sub(r'[] \1', buf) - - # make return types that are const work. - buf = re.sub(r'\s*\*\s*G_CONST_RETURN\s*\*\s*', '** ', buf) - buf = string.replace(buf, 'G_CONST_RETURN ', 'const-') - buf = string.replace(buf, 'const ', 'const-') - - #strip GSEAL macros from the middle of function declarations: - pat = re.compile(r"""GSEAL""", re.VERBOSE) - buf = pat.sub('', buf) - - return buf - -proto_pat=re.compile(r""" -(?P(-|\w|\&|\*)+\s*) # return type -\s+ # skip whitespace -(?P\w+)\s*[(] # match the function name until the opening ( -\s*(?P.*?)\s*[)] # group the function arguments -""", re.IGNORECASE|re.VERBOSE) -#""" -arg_split_pat = re.compile("\s*,\s*") - -get_type_pat = re.compile(r'(const-)?([A-Za-z0-9]+)\*?\s+') -pointer_pat = re.compile('.*\*$') -func_new_pat = re.compile('(\w+)_new$') - -class DefsWriter: - def __init__(self, fp=None, prefix=None, ns=None, verbose=False, - defsfilter=None): - if not fp: - fp = sys.stdout - - self.fp = fp - self.prefix = prefix - self.namespace = ns - self.verbose = verbose - - self._enums = {} - self._objects = {} - self._functions = {} - if defsfilter: - filter = defsparser.DefsParser(defsfilter) - filter.startParsing() - for func in filter.functions + filter.methods.values(): - self._functions[func.c_name] = func - for obj in filter.objects + filter.boxes + filter.interfaces: - self._objects[obj.c_name] = obj - for obj in filter.enums: - self._enums[obj.c_name] = obj - - def write_def(self, deffile): - buf = open(deffile).read() - - self.fp.write('\n;; From %s\n\n' % os.path.basename(deffile)) - self._define_func(buf) - self.fp.write('\n') - - def write_enum_defs(self, enums, fp=None): - if not fp: - fp = self.fp - - fp.write(';; Enumerations and flags ...\n\n') - trans = string.maketrans(string.uppercase + '_', - string.lowercase + '-') - filter = self._enums - for cname, isflags, entries in enums: - if filter: - if cname in filter: - continue - name = cname - module = None - if self.namespace: - module = self.namespace - name = cname[len(self.namespace):] - else: - m = split_prefix_pat.match(cname) - if m: - module = m.group(1) - name = m.group(2) - if isflags: - fp.write('(define-flags ' + name + '\n') - else: - fp.write('(define-enum ' + name + '\n') - if module: - fp.write(' (in-module "' + module + '")\n') - fp.write(' (c-name "' + cname + '")\n') - fp.write(' (gtype-id "' + typecode(cname, self.namespace) + '")\n') - prefix = entries[0] - for ent in entries: - # shorten prefix til we get a match ... - # and handle GDK_FONT_FONT, GDK_FONT_FONTSET case - while ((len(prefix) and prefix[-1] != '_') or ent[:len(prefix)] != prefix - or len(prefix) >= len(ent)): - prefix = prefix[:-1] - prefix_len = len(prefix) - fp.write(' (values\n') - for ent in entries: - fp.write(' \'("%s" "%s")\n' % - (string.translate(ent[prefix_len:], trans), ent)) - fp.write(' )\n') - fp.write(')\n\n') - - def write_obj_defs(self, objdefs, fp=None): - if not fp: - fp = self.fp - - fp.write(';; -*- scheme -*-\n') - fp.write('; object definitions ...\n') - - filter = self._objects - for klass, parent in objdefs: - if filter: - if klass in filter: - continue - if self.namespace: - cname = klass[len(self.namespace):] - cmodule = self.namespace - else: - m = split_prefix_pat.match(klass) - cname = klass - cmodule = None - if m: - cmodule = m.group(1) - cname = m.group(2) - fp.write('(define-object ' + cname + '\n') - if cmodule: - fp.write(' (in-module "' + cmodule + '")\n') - if parent: - fp.write(' (parent "' + parent + '")\n') - fp.write(' (c-name "' + klass + '")\n') - fp.write(' (gtype-id "' + typecode(klass, self.namespace) + '")\n') - # should do something about accessible fields - fp.write(')\n\n') - - def _define_func(self, buf): - buf = clean_func(buf) - buf = string.split(buf,'\n') - filter = self._functions - for p in buf: - if not p: - continue - m = proto_pat.match(p) - if m == None: - if self.verbose: - sys.stderr.write('No match:|%s|\n' % p) - continue - func = m.group('func') - if func[0] == '_': - continue - if filter: - if func in filter: - continue - ret = m.group('ret') - args = m.group('args') - args = arg_split_pat.split(args) - for i in range(len(args)): - spaces = string.count(args[i], ' ') - if spaces > 1: - args[i] = string.replace(args[i], ' ', '-', spaces - 1) - - self._write_func(func, ret, args) - - def _write_func(self, name, ret, args): - if len(args) >= 1: - # methods must have at least one argument - munged_name = name.replace('_', '') - m = get_type_pat.match(args[0]) - if m: - obj = m.group(2) - if munged_name[:len(obj)] == obj.lower(): - self._write_method(obj, name, ret, args) - return - - if self.prefix: - l = len(self.prefix) - if name[:l] == self.prefix and name[l] == '_': - fname = name[l+1:] - else: - fname = name - else: - fname = name - - # it is either a constructor or normal function - self.fp.write('(define-function ' + fname + '\n') - self.fp.write(' (c-name "' + name + '")\n') - - # Hmmm... Let's asume that a constructor function name - # ends with '_new' and it returns a pointer. - m = func_new_pat.match(name) - if pointer_pat.match(ret) and m: - cname = '' - names = m.group(1).split('_') - - if self.namespace: - cname = self.namespace - names = names[1:] - - for s in names: - cname += s.title() - if cname != '': - self.fp.write(' (is-constructor-of "' + cname + '")\n') - - self._write_return(ret) - self._write_arguments(args) - - def _write_method(self, obj, name, ret, args): - regex = string.join(map(lambda x: x+'_?', string.lower(obj)),'') - mname = re.sub(regex, '', name, 1) - if self.prefix: - l = len(self.prefix) + 1 - if mname[:l] == self.prefix and mname[l+1] == '_': - mname = mname[l+1:] - self.fp.write('(define-method ' + mname + '\n') - self.fp.write(' (of-object "' + obj + '")\n') - self.fp.write(' (c-name "' + name + '")\n') - self._write_return(ret) - self._write_arguments(args[1:]) - - def _write_return(self, ret): - if ret != 'void': - self.fp.write(' (return-type "' + ret + '")\n') - else: - self.fp.write(' (return-type "none")\n') - - def _write_arguments(self, args): - is_varargs = 0 - has_args = len(args) > 0 - for arg in args: - if arg == '...': - is_varargs = 1 - elif arg in ('void', 'void '): - has_args = 0 - if has_args: - self.fp.write(' (parameters\n') - for arg in args: - if arg != '...': - tupleArg = tuple(string.split(arg)) - if len(tupleArg) == 2: - self.fp.write(' \'("%s" "%s")\n' % tupleArg) - self.fp.write(' )\n') - if is_varargs: - self.fp.write(' (varargs #t)\n') - self.fp.write(')\n\n') - -# ------------------ Main function ----------------- - -def main(args): - verbose = False - onlyenums = False - onlyobjdefs = False - separate = False - modulename = None - namespace = None - defsfilter = None - opts, args = getopt.getopt(args[1:], 'vs:m:n:f:', - ['onlyenums', 'onlyobjdefs', - 'modulename=', 'namespace=', - 'separate=', 'defsfilter=']) - for o, v in opts: - if o == '-v': - verbose = True - if o == '--onlyenums': - onlyenums = True - if o == '--onlyobjdefs': - onlyobjdefs = True - if o in ('-s', '--separate'): - separate = v - if o in ('-m', '--modulename'): - modulename = v - if o in ('-n', '--namespace'): - namespace = v - if o in ('-f', '--defsfilter'): - defsfilter = v - - if not args[0:1]: - print 'Must specify at least one input file name' - return -1 - - # read all the object definitions in - objdefs = [] - enums = [] - for filename in args: - buf = open(filename).read() - find_obj_defs(buf, objdefs) - find_enum_defs(buf, enums) - objdefs = sort_obj_defs(objdefs) - - if separate: - methods = file(separate + '.defs', 'w') - types = file(separate + '-types.defs', 'w') - - dw = DefsWriter(methods, prefix=modulename, ns=namespace, - verbose=verbose, defsfilter=defsfilter) - dw.write_obj_defs(objdefs, types) - dw.write_enum_defs(enums, types) - print "Wrote %s-types.defs" % separate - - for filename in args: - dw.write_def(filename) - print "Wrote %s.defs" % separate - else: - dw = DefsWriter(prefix=modulename, ns=namespace, - verbose=verbose, defsfilter=defsfilter) - - if onlyenums: - dw.write_enum_defs(enums) - elif onlyobjdefs: - dw.write_obj_defs(objdefs) - else: - dw.write_obj_defs(objdefs) - dw.write_enum_defs(enums) - - for filename in args: - dw.write_def(filename) - -if __name__ == '__main__': - sys.exit(main(sys.argv)) diff --git a/bindings/python/codegen/mergedefs.py b/bindings/python/codegen/mergedefs.py deleted file mode 100755 index 773e499bb0..0000000000 --- a/bindings/python/codegen/mergedefs.py +++ /dev/null @@ -1,26 +0,0 @@ -#!/usr/bin/env python -# -*- Mode: Python; py-indent-offset: 4 -*- - -import optparse - -import defsparser - -parser = optparse.OptionParser( - usage="usage: %prog [options] generated-defs old-defs") -parser.add_option("-p", "--merge-parameters", - help="Merge changes in function/methods parameter lists", - action="store_true", dest="parmerge", default=False) -(options, args) = parser.parse_args() - -if len(args) != 2: - parser.error("wrong number of arguments") - -newp = defsparser.DefsParser(args[0]) -oldp = defsparser.DefsParser(args[1]) - -newp.startParsing() -oldp.startParsing() - -newp.merge(oldp, options.parmerge) - -newp.write_defs() diff --git a/bindings/python/codegen/mkskel.py b/bindings/python/codegen/mkskel.py deleted file mode 100755 index 61f520bf73..0000000000 --- a/bindings/python/codegen/mkskel.py +++ /dev/null @@ -1,89 +0,0 @@ -#!/usr/bin/env python -# -*- Mode: Python; py-indent-offset: 4 -*- - -import sys, os, getopt - -module_init_template = \ -'/* -*- Mode: C; c-basic-offset: 4 -*- */\n' + \ -'#ifdef HAVE_CONFIG_H\n' + \ -'# include "config.h"\n' + \ -'#endif\n' + \ -'#include \n' + \ -'#include \n' + \ -'\n' + \ -'/* include any extra headers needed here */\n' + \ -'\n' + \ -'void %(prefix)s_register_classes(PyObject *d);\n' + \ -'extern PyMethodDef %(prefix)s_functions[];\n' + \ -'\n' + \ -'DL_EXPORT(void)\n' + \ -'init%(module)s(void)\n' + \ -'{\n' + \ -' PyObject *m, *d;\n' + \ -'\n' + \ -' /* perform any initialisation required by the library here */\n' + \ -'\n' + \ -' m = Py_InitModule("%(module)s", %(prefix)s_functions);\n' + \ -' d = PyModule_GetDict(m);\n' + \ -'\n' + \ -' init_pygtk();\n' + \ -'\n' + \ -' %(prefix)s_register_classes(d);\n' + \ -'\n' + \ -' /* add anything else to the module dictionary (such as constants) */\n' +\ -'\n' + \ -' if (PyErr_Occurred())\n' + \ -' Py_FatalError("could not initialise module %(module)s");\n' + \ -'}\n' - -override_template = \ -'/* -*- Mode: C; c-basic-offset: 4 -*- */\n' + \ -'%%%%\n' + \ -'headers\n' + \ -'/* include any required headers here */\n' + \ -'%%%%\n' + \ -'init\n' + \ -' /* include any code here that needs to be executed before the\n' + \ -' * extension classes get initialised */\n' + \ -'%%%%\n' + \ -'\n' + \ -'/* you should add appropriate ignore, ignore-glob and\n' + \ -' * override sections here */\n' - -def open_with_backup(file): - if os.path.exists(file): - try: - os.rename(file, file+'~') - except OSError: - # fail silently if we can't make a backup - pass - return open(file, 'w') - -def write_skels(fileprefix, prefix, module): - fp = open_with_backup(fileprefix+'module.c') - fp.write(module_init_template % { 'prefix': prefix, 'module': module }) - fp.close() - fp = open_with_backup(fileprefix+'.override') - fp.write(override_template % { 'prefix': prefix, 'module': module }) - fp.close() - -if __name__ == '__main__': - opts, args = getopt.getopt(sys.argv[1:], 'f:p:m:h', - ['file-prefix=', 'prefix=', 'module=', 'help']) - fileprefix = None - prefix = None - module = None - for opt, arg in opts: - if opt in ('-f', '--file-prefix'): - fileprefix = arg - elif opt in ('-p', '--prefix'): - prefix = arg - elif opt in ('-m', '--module'): - module = arg - elif opt in ('-h', '--help'): - print 'usage: mkskel.py -f fileprefix -p prefix -m module' - sys.exit(0) - if not fileprefix or not prefix or not module: - print 'usage: mkskel.py -f fileprefix -p prefix -m module' - sys.exit(1) - write_skels(fileprefix, prefix, module) diff --git a/bindings/python/codegen/override.py b/bindings/python/codegen/override.py deleted file mode 100644 index bba5e4291a..0000000000 --- a/bindings/python/codegen/override.py +++ /dev/null @@ -1,285 +0,0 @@ -# -*- Mode: Python; py-indent-offset: 4 -*- - -# this file contains code for loading up an override file. The override file -# provides implementations of functions where the code generator could not -# do its job correctly. - -import fnmatch -import os -import re -import string -import sys - -def class2cname(klass, method): - c_name = '' - for c in klass: - if c.isupper(): - c_name += '_' + c.lower() - else: - c_name += c - return c_name[1:] + '_' + method - -# import python_type as c_name [for arg_type] -# Last ('for') clause is optional. If present, the type will be -# imported only if given 'arg_type' is registered. -import_pat = re.compile(r'\s*import\s+(\S+)\.([^\s.]+)\s+as\s+(\S+)(\s+for\s+(\S+))?') - -class Overrides: - def __init__(self, filename=None): - self.modulename = None - self.ignores = {} - self.glob_ignores = [] - self.type_ignores = {} - self.overrides = {} - self.overridden = {} - self.kwargs = {} - self.noargs = {} - self.onearg = {} - self.staticmethod = {} - self.classmethod = {} - self.startlines = {} - self.override_attrs = {} - self.override_slots = {} - self.headers = '' - self.body = '' - self.init = '' - self.imports = [] - self.defines = {} - self.functions = {} - self.newstyle_constructors = {} - self.dynamicnamespace = False - if filename: - self.handle_file(filename) - - def handle_file(self, filename): - oldpath = os.getcwd() - - fp = open(filename, 'r') - dirname = os.path.dirname(os.path.abspath(filename)) - - if dirname != oldpath: - os.chdir(dirname) - - # read all the components of the file ... - bufs = [] - startline = 1 - lines = [] - line = fp.readline() - linenum = 1 - while line: - if line == '%%\n' or line == '%%': - if lines: - bufs.append((string.join(lines, ''), startline)) - startline = linenum + 1 - lines = [] - else: - lines.append(line) - line = fp.readline() - linenum = linenum + 1 - if lines: - bufs.append((string.join(lines, ''), startline)) - if not bufs: return - - for buf, startline in bufs: - self.__parse_override(buf, startline, filename) - - os.chdir(oldpath) - - def __parse_override(self, buffer, startline, filename): - pos = string.find(buffer, '\n') - if pos >= 0: - line = buffer[:pos] - rest = buffer[pos+1:] - else: - line = buffer ; rest = '' - words = string.split(line) - command = words[0] - if (command == 'ignore' or - command == 'ignore-' + sys.platform): - "ignore/ignore-platform [functions..]" - for func in words[1:]: - self.ignores[func] = 1 - for func in string.split(rest): - self.ignores[func] = 1 - elif (command == 'ignore-glob' or - command == 'ignore-glob-' + sys.platform): - "ignore-glob/ignore-glob-platform [globs..]" - for func in words[1:]: - self.glob_ignores.append(func) - for func in string.split(rest): - self.glob_ignores.append(func) - elif (command == 'ignore-type' or - command == 'ignore-type-' + sys.platform): - "ignore-type/ignore-type-platform [typenames..]" - for typename in words[1:]: - self.type_ignores[typename] = 1 - for typename in string.split(rest): - self.type_ignores[typename] = 1 - elif command == 'override': - "override function/method [kwargs|noargs|onearg] [staticmethod|classmethod]" - func = words[1] - if 'kwargs' in words[1:]: - self.kwargs[func] = 1 - elif 'noargs' in words[1:]: - self.noargs[func] = 1 - elif 'onearg' in words[1:]: - self.onearg[func] = True - - if 'staticmethod' in words[1:]: - self.staticmethod[func] = True - elif 'classmethod' in words[1:]: - self.classmethod[func] = True - if func in self.overrides: - raise RuntimeError("Function %s is being overridden more than once" % (func,)) - self.overrides[func] = rest - self.startlines[func] = (startline + 1, filename) - elif command == 'override-attr': - "override-slot Class.attr" - attr = words[1] - self.override_attrs[attr] = rest - self.startlines[attr] = (startline + 1, filename) - elif command == 'override-slot': - "override-slot Class.slot" - slot = words[1] - self.override_slots[slot] = rest - self.startlines[slot] = (startline + 1, filename) - elif command == 'headers': - "headers" - self.headers = '%s\n#line %d "%s"\n%s' % \ - (self.headers, startline + 1, filename, rest) - elif command == 'body': - "body" - self.body = '%s\n#line %d "%s"\n%s' % \ - (self.body, startline + 1, filename, rest) - elif command == 'init': - "init" - self.init = '%s\n#line %d "%s"\n%s' % \ - (self.init, startline + 1, filename, rest) - elif command == 'modulename': - "modulename name" - self.modulename = words[1] - elif command == 'include': - "include filename" - for filename in words[1:]: - self.handle_file(filename) - for filename in string.split(rest): - self.handle_file(filename) - elif command == 'import': - "import module1 [\n module2, \n module3 ...]" - for line in string.split(buffer, '\n'): - match = import_pat.match(line) - if match: - module, pyname, cname, conditional, importing_for = match.groups() - self.imports.append((module, pyname, cname, importing_for or None)) - elif command == 'define': - "define funcname [kwargs|noargs|onearg] [classmethod|staticmethod]" - "define Class.method [kwargs|noargs|onearg] [classmethod|staticmethod]" - func = words[1] - klass = None - if func.find('.') != -1: - klass, func = func.split('.', 1) - - if not self.defines.has_key(klass): - self.defines[klass] = {} - self.defines[klass][func] = rest - else: - self.functions[func] = rest - - if 'kwargs' in words[1:]: - self.kwargs[func] = 1 - elif 'noargs' in words[1:]: - self.noargs[func] = 1 - elif 'onearg' in words[1:]: - self.onearg[func] = 1 - - if 'staticmethod' in words[1:]: - self.staticmethod[func] = True - elif 'classmethod' in words[1:]: - self.classmethod[func] = True - - self.startlines[func] = (startline + 1, filename) - - elif command == 'new-constructor': - "new-constructor GType" - gtype, = words[1:] - self.newstyle_constructors[gtype] = True - elif command == 'options': - for option in words[1:]: - if option == 'dynamicnamespace': - self.dynamicnamespace = True - - def is_ignored(self, name): - if self.ignores.has_key(name): - return 1 - for glob in self.glob_ignores: - if fnmatch.fnmatchcase(name, glob): - return 1 - return 0 - - def is_type_ignored(self, name): - return name in self.type_ignores - - def is_overriden(self, name): - return self.overrides.has_key(name) - - def is_already_included(self, name): - return self.overridden.has_key(name) - - def override(self, name): - self.overridden[name] = 1 - return self.overrides[name] - - def define(self, klass, name): - self.overridden[class2cname(klass, name)] = 1 - return self.defines[klass][name] - - def function(self, name): - return self.functions[name] - - def getstartline(self, name): - return self.startlines[name] - - def wants_kwargs(self, name): - return self.kwargs.has_key(name) - - def wants_noargs(self, name): - return self.noargs.has_key(name) - - def wants_onearg(self, name): - return self.onearg.has_key(name) - - def is_staticmethod(self, name): - return self.staticmethod.has_key(name) - - def is_classmethod(self, name): - return self.classmethod.has_key(name) - - def attr_is_overriden(self, attr): - return self.override_attrs.has_key(attr) - - def attr_override(self, attr): - return self.override_attrs[attr] - - def slot_is_overriden(self, slot): - return self.override_slots.has_key(slot) - - def slot_override(self, slot): - return self.override_slots[slot] - - def get_headers(self): - return self.headers - - def get_body(self): - return self.body - - def get_init(self): - return self.init - - def get_imports(self): - return self.imports - - def get_defines_for(self, klass): - return self.defines.get(klass, {}) - - def get_functions(self): - return self.functions diff --git a/bindings/python/codegen/reversewrapper.py b/bindings/python/codegen/reversewrapper.py deleted file mode 100644 index b96e12e1dd..0000000000 --- a/bindings/python/codegen/reversewrapper.py +++ /dev/null @@ -1,912 +0,0 @@ -### -*- python -*- -### Code to generate "Reverse Wrappers", i.e. C->Python wrappers -### (C) 2004 Gustavo Carneiro -import argtypes -import os - -DEBUG_MODE = ('PYGTK_CODEGEN_DEBUG' in os.environ) - -def join_ctype_name(ctype, name): - '''Joins a C type and a variable name into a single string''' - if ctype[-1] != '*': - return " ".join((ctype, name)) - else: - return "".join((ctype, name)) - - -class CodeSink(object): - def __init__(self): - self.indent_level = 0 # current indent level - self.indent_stack = [] # previous indent levels - - def _format_code(self, code): - assert isinstance(code, str) - l = [] - for line in code.split('\n'): - l.append(' '*self.indent_level + line) - if l[-1]: - l.append('') - return '\n'.join(l) - - def writeln(self, line=''): - raise NotImplementedError - - def indent(self, level=4): - '''Add a certain ammount of indentation to all lines written - from now on and until unindent() is called''' - self.indent_stack.append(self.indent_level) - self.indent_level += level - - def unindent(self): - '''Revert indentation level to the value before last indent() call''' - self.indent_level = self.indent_stack.pop() - - -class FileCodeSink(CodeSink): - def __init__(self, fp): - CodeSink.__init__(self) - assert isinstance(fp, file) - self.fp = fp - - def writeln(self, line=''): - self.fp.write(self._format_code(line)) - -class MemoryCodeSink(CodeSink): - def __init__(self): - CodeSink.__init__(self) - self.lines = [] - - def writeln(self, line=''): - self.lines.append(self._format_code(line)) - - def flush_to(self, sink): - assert isinstance(sink, CodeSink) - for line in self.lines: - sink.writeln(line.rstrip()) - self.lines = [] - - def flush(self): - l = [] - for line in self.lines: - l.append(self._format_code(line)) - self.lines = [] - return "".join(l) - -class ReverseWrapper(object): - '''Object that generates a C->Python wrapper''' - def __init__(self, cname, is_static=True): - assert isinstance(cname, str) - - self.cname = cname - ## function object we will call, or object whose method we will call - self.called_pyobj = None - ## name of method of self.called_pyobj we will call - self.method_name = None - self.is_static = is_static - - self.parameters = [] - self.declarations = MemoryCodeSink() - self.post_return_code = MemoryCodeSink() - self.body = MemoryCodeSink() - self.check_exception_code = MemoryCodeSink() - self.cleanup_actions = [] - self.pyargv_items = [] - self.pyargv_optional_items = [] - self.pyret_parse_items = [] # list of (format_spec, parameter) - self.code_sinks_stack = [self.body] - - def set_call_target(self, called_pyobj, method_name=None): - assert called_pyobj is not None - assert self.called_pyobj is None - self.called_pyobj = called_pyobj - self.method_name = method_name - - def set_return_type(self, return_type): - assert isinstance(return_type, ReturnType) - self.return_type = return_type - - def add_parameter(self, param): - assert isinstance(param, Parameter) - self.parameters.append(param) - - def add_declaration(self, decl_code): - self.declarations.writeln(decl_code) - - def add_pyargv_item(self, variable, optional=False): - if optional: - self.pyargv_optional_items.append(variable) - else: - self.pyargv_items.append(variable) - - def add_pyret_parse_item(self, format_specifier, parameter, prepend=False): - if prepend: - self.pyret_parse_items.insert(0, (format_specifier, parameter)) - else: - self.pyret_parse_items.append((format_specifier, parameter)) - - - def push_code_sink(self, code_sink): - self.code_sinks_stack.insert(0, code_sink) - - def pop_code_sink(self): - return self.code_sinks_stack.pop(0) - - - def write_code(self, code, - cleanup=None, - failure_expression=None, - failure_cleanup=None, - failure_exception=None, - code_sink=None): - '''Add a chunk of code with cleanup and error handling - - This method is to be used by TypeHandlers when generating code - - Keywork arguments: - code -- code to add - cleanup -- code to cleanup any dynamic resources created by @code - (except in case of failure) (default None) - failure_expression -- C boolean expression to indicate - if anything failed (default None) - failure_cleanup -- code to cleanup any dynamic resources - created by @code in case of failure (default None) - failure_exception -- code to raise an exception in case of - failure (which will be immediately - printed and cleared), (default None) - code_sink -- "code sink" to use; by default, - ReverseWrapper.body is used, which writes the - main body of the wrapper, before calling the - python method. Alternatively, - ReverseWrapper.after_pyret_parse can be used, to - write code after the PyArg_ParseTuple that - parses the python method return value. - ''' - if code_sink is None: - code_sink = self.code_sinks_stack[0] - if code is not None: - code_sink.writeln(code) - if failure_expression is not None: - code_sink.writeln("if (%s) {" % (failure_expression,)) - code_sink.indent() - if failure_exception is None: - code_sink.writeln("if (PyErr_Occurred())") - code_sink.indent() - code_sink.writeln("PyErr_Print();") - code_sink.unindent() - else: - code_sink.writeln(failure_exception) - code_sink.writeln("PyErr_Print();") - if failure_cleanup is not None: - code_sink.writeln(failure_cleanup) - for cleanup_action in self.cleanup_actions: - code_sink.writeln(cleanup_action) - - self.push_code_sink(code_sink) - try: - self.return_type.write_error_return() - finally: - self.pop_code_sink() - - code_sink.unindent() - code_sink.writeln("}") - if cleanup is not None: - self.cleanup_actions.insert(0, cleanup) - - def generate(self, sink): - '''Generate the code into a CodeSink object''' - assert isinstance(sink, CodeSink) - - if DEBUG_MODE: - self.declarations.writeln("/* begin declarations */") - self.body.writeln("/* begin main body */") - self.post_return_code.writeln("/* begin post-return code */") - - self.add_declaration("PyGILState_STATE __py_state;") - self.write_code(code="__py_state = pyg_gil_state_ensure();", - cleanup="pyg_gil_state_release(__py_state);") - - for param in self.parameters: - param.convert_c2py() - - assert self.called_pyobj is not None,\ - "Parameters failed to provide a target function or method." - - if self.is_static: - sink.writeln('static %s' % self.return_type.get_c_type()) - else: - sink.writeln(self.return_type.get_c_type()) - c_proto_params = map(Parameter.format_for_c_proto, self.parameters) - sink.writeln("%s(%s)\n{" % (self.cname, ", ".join(c_proto_params))) - - self.return_type.write_decl() - self.add_declaration("PyObject *py_retval;") - - ## Handle number of arguments - if self.pyargv_items: - self.add_declaration("PyObject *py_args;") - py_args = "py_args" - if self.pyargv_optional_items: - self.add_declaration("int argc = %i;" % len(self.pyargv_items)) - argc = "argc" - for arg in self.pyargv_optional_items: - self.body.writeln("if (%s)" % arg) - self.body.indent() - self.body.writeln("++argc;") - self.body.unindent() - else: - argc = str(len(self.pyargv_items)) - else: - if self.pyargv_optional_items: - self.add_declaration("PyObject *py_args;") - py_args = "py_args" - self.add_declaration("int argc = 0;") - argc = "argc" - for arg in self.pyargv_optional_items: - self.body.writeln("if (%s)" % arg) - self.body.indent() - self.body.writeln("++argc;") - self.body.unindent() - else: - py_args = "NULL" - argc = None - - self.body.writeln() - - if py_args != "NULL": - self.write_code("py_args = PyTuple_New(%s);" % argc, - cleanup="Py_DECREF(py_args);") - pos = 0 - for arg in self.pyargv_items: - try: # try to remove the Py_DECREF cleanup action, if we can - self.cleanup_actions.remove("Py_DECREF(%s);" % arg) - except ValueError: # otherwise we have to Py_INCREF.. - self.body.writeln("Py_INCREF(%s);" % arg) - self.body.writeln("PyTuple_SET_ITEM(%s, %i, %s);" % (py_args, pos, arg)) - pos += 1 - for arg in self.pyargv_optional_items: - self.body.writeln("if (%s) {" % arg) - self.body.indent() - try: # try to remove the Py_DECREF cleanup action, if we can - self.cleanup_actions.remove("Py_XDECREF(%s);" % arg) - except ValueError: # otherwise we have to Py_INCREF.. - self.body.writeln("Py_INCREF(%s);" % arg) - self.body.writeln("PyTuple_SET_ITEM(%s, %i, %s);" % (py_args, pos, arg)) - self.body.unindent() - self.body.writeln("}") - pos += 1 - - self.body.writeln() - - ## Call the python method - if self.method_name is None: - self.write_code("py_retval = PyObject_Call(%s, %s);" - % (self.called_pyobj, py_args), - cleanup="Py_XDECREF(py_retval);") - self.check_exception_code.flush_to(self.body) - self.write_code(None, failure_expression="!py_retval") - - else: - self.add_declaration("PyObject *py_method;") - self.write_code("py_method = PyObject_GetAttrString(%s, \"%s\");" - % (self.called_pyobj, self.method_name), - cleanup="Py_DECREF(py_method);", - failure_expression="!py_method") - self.write_code("py_retval = PyObject_CallObject(py_method, %s);" - % (py_args,), - cleanup="Py_XDECREF(py_retval);") - self.check_exception_code.flush_to(self.body) - self.write_code(None, failure_expression="!py_retval") - - ## -- Handle the return value -- - - ## we need to check if the return_type object is prepared to cooperate with multiple return values - len_before = len(self.pyret_parse_items) - self.return_type.write_conversion() - len_after = len(self.pyret_parse_items) - assert (self.return_type.get_c_type() == 'void' - or not (len_before == len_after and len_after > 0)),\ - ("Bug in reverse wrappers: return type handler %s" - " is not prepared to cooperate multiple return values") % (type(self.return_type),) - - sink.indent() - - if self.pyret_parse_items == [("", "")]: - ## special case when there are no return parameters - self.write_code( - code=None, - failure_expression='py_retval != Py_None', - failure_exception=('PyErr_SetString(PyExc_TypeError, ' - '"virtual method should return None");')) - else: - if len(self.pyret_parse_items) == 1: - ## if retval is one item only, pack it in a tuple so we - ## can use PyArg_ParseTuple as usual.. - self.write_code('py_retval = Py_BuildValue("(N)", py_retval);') - if len(self.pyret_parse_items) > 0: - ## Parse return values using PyArg_ParseTuple - params = ["py_retval", - '"%s"' % "".join([format for format, param in self.pyret_parse_items])] - params.extend([param for format, param in self.pyret_parse_items if param]) - self.write_code(code=None, failure_expression=( - '!PyArg_ParseTuple(%s)' % (', '.join(params),))) - - if DEBUG_MODE: - self.declarations.writeln("/* end declarations */") - self.declarations.flush_to(sink) - sink.writeln() - if DEBUG_MODE: - self.body.writeln("/* end main body */") - self.body.flush_to(sink) - sink.writeln() - if DEBUG_MODE: - self.post_return_code.writeln("/* end post-return code */") - self.post_return_code.flush_to(sink) - sink.writeln() - - for cleanup_action in self.cleanup_actions: - sink.writeln(cleanup_action) - if self.return_type.get_c_type() != 'void': - sink.writeln() - sink.writeln("return retval;") - sink.unindent() - sink.writeln("}") - -class TypeHandler(object): - def __init__(self, wrapper, **props): - assert isinstance(wrapper, ReverseWrapper) - self.wrapper = wrapper - self.props = props - -class ReturnType(TypeHandler): - - supports_optional = False - - def get_c_type(self): - raise NotImplementedError - - def write_decl(self): - raise NotImplementedError - - def write_error_return(self): - '''Write "return " code in case of error''' - raise NotImplementedError - - def write_conversion(self): - '''Writes code to convert Python return value in 'py_retval' - into C 'retval'. Returns a string with C boolean expression - that determines if anything went wrong. ''' - raise NotImplementedError - -class Parameter(TypeHandler): - - def __init__(self, wrapper, name, **props): - TypeHandler.__init__(self, wrapper, **props) - self.name = name - - def get_c_type(self): - raise NotImplementedError - - def convert_c2py(self): - '''Write some code before calling the Python method.''' - pass - - def format_for_c_proto(self): - return join_ctype_name(self.get_c_type(), self.name) - - -###--- -class StringParam(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'char *').replace('const-', 'const ') - - def convert_c2py(self): - if self.props.get('optional', False): - self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name) - self.wrapper.write_code(code=("if (%s)\n" - " py_%s = PyString_FromString(%s);\n" - % (self.name, self.name, self.name)), - cleanup=("Py_XDECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name, optional=True) - elif self.props.get('nullok', False): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("if (%s)\n" - " py_%s = PyString_FromString(%s);\n" - "else {\n" - " Py_INCREF(Py_None);\n" - " py_%s = Py_None;\n" - "}\n" - % (self.name, self.name, self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - else: - self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name) - self.wrapper.write_code(code=("if (%s)\n" - " py_%s = PyString_FromString(%s);\n" % - (self.name, self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name), - failure_expression=("!py_%s" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -for ctype in ('char*', 'gchar*', 'const-char*', 'char-const*', 'const-gchar*', - 'gchar-const*', 'string', 'static_string'): - argtypes.matcher.register_reverse(ctype, StringParam) -del ctype - -class StringReturn(ReturnType): - - def get_c_type(self): - return self.props.get('c_type', 'char *').replace('const-', 'const ') - #return "char *" - - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - #self.wrapper.add_declaration("char *retval;") - - def write_error_return(self): - self.wrapper.write_code("return NULL;") - - def write_conversion(self): - self.wrapper.add_pyret_parse_item("s", "&retval", prepend=True) - self.wrapper.write_code("retval = g_strdup(retval);", code_sink=self.wrapper.post_return_code) - -for ctype in ('char*', 'gchar*', 'const-gchar*'): - argtypes.matcher.register_reverse_ret(ctype, StringReturn) -del ctype - - -class VoidReturn(ReturnType): - - def get_c_type(self): - return "void" - - def write_decl(self): - pass - - def write_error_return(self): - self.wrapper.write_code("return;") - - def write_conversion(self): - self.wrapper.add_pyret_parse_item("", "", prepend=True) - -argtypes.matcher.register_reverse_ret('void', VoidReturn) -argtypes.matcher.register_reverse_ret('none', VoidReturn) - -class GObjectParam(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'GObject *') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s = NULL;" % self.name) - self.wrapper.write_code(code=("if (%s)\n" - " py_%s = pygobject_new((GObject *) %s);\n" - "else {\n" - " Py_INCREF(Py_None);\n" - " py_%s = Py_None;\n" - "}" - % (self.name, self.name, self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse('GObject*', GObjectParam) - -class GObjectReturn(ReturnType): - - supports_optional = True - - def get_c_type(self): - return self.props.get('c_type', 'GObject *') - - def write_decl(self): - if not self.props.get('optional'): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - else: - self.wrapper.add_declaration("%s retval = NULL;" % self.get_c_type()) - - def write_error_return(self): - self.wrapper.write_code("return NULL;") - - def write_conversion(self): - if not self.props.get('optional'): - self.wrapper.write_code( - code=None, - failure_expression="!PyObject_TypeCheck(py_retval, &PyGObject_Type)", - failure_exception='PyErr_SetString(PyExc_TypeError, "retval should be a GObject");') - self.wrapper.write_code("retval = (%s) pygobject_get(py_retval);" - % self.get_c_type()) - self.wrapper.write_code("g_object_ref((GObject *) retval);") - else: - self.wrapper.write_code( - code=None, - failure_expression="py_retval != Py_None && !PyObject_TypeCheck(py_retval, &PyGObject_Type)", - failure_exception='PyErr_SetString(PyExc_TypeError, "retval should be None or a GObject");') - self.wrapper.write_code("if (py_retval != Py_None) {\n" - " retval = (%s) pygobject_get(py_retval);\n" - " g_object_ref((GObject *) retval);\n" - "}\n" - % self.get_c_type()) - -argtypes.matcher.register_reverse_ret('GObject*', GObjectReturn) - - - -class IntParam(Parameter): - - def get_c_type(self): - return self.props.get('c_type', 'int') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = PyInt_FromLong(%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -class IntReturn(ReturnType): - def get_c_type(self): - return self.props.get('c_type', 'int') - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - def write_error_return(self): - self.wrapper.write_code("return -G_MAXINT;") - def write_conversion(self): - self.wrapper.add_pyret_parse_item("i", "&retval", prepend=True) - -for argtype in ('int', 'gint', 'guint', 'short', 'gshort', 'gushort', 'long', - 'glong', 'gsize', 'gssize', 'guint8', 'gint8', 'guint16', - 'gint16', 'gint32', 'GTime'): - argtypes.matcher.register_reverse(argtype, IntParam) - argtypes.matcher.register_reverse_ret(argtype, IntReturn) -del argtype - -class IntPtrParam(Parameter): - def __init__(self, wrapper, name, **props): - if "direction" not in props: - raise argtypes.ArgTypeConfigurationError( - "cannot use int* parameter without direction") - if props["direction"] not in ("out", "inout"): - raise argtypes.ArgTypeConfigurationError( - "cannot use int* parameter with direction '%s'" - % (props["direction"],)) - Parameter.__init__(self, wrapper, name, **props) - def get_c_type(self): - return self.props.get('c_type', 'int*') - def convert_c2py(self): - if self.props["direction"] == "inout": - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = PyInt_FromLong(*%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - self.wrapper.add_pyret_parse_item("i", self.name) -for argtype in ('int*', 'gint*'): - argtypes.matcher.register_reverse(argtype, IntPtrParam) -del argtype - - -class GEnumReturn(IntReturn): - def write_conversion(self): - self.wrapper.write_code( - code=None, - failure_expression=( - "pyg_enum_get_value(%s, py_retval, (gint *)&retval)" - % (self.props['typecode'],))) - -argtypes.matcher.register_reverse_ret("GEnum", GEnumReturn) - -class GEnumParam(IntParam): - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = pyg_enum_from_gtype(%s, %s);" % - (self.name, self.props['typecode'], self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name), - failure_expression=("!py_%s" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse("GEnum", GEnumParam) - -class GFlagsReturn(IntReturn): - def write_conversion(self): - self.wrapper.write_code( - code=None, - failure_expression=( - "pyg_flags_get_value(%s, py_retval, (gint *)&retval)" % - self.props['typecode'])) - -argtypes.matcher.register_reverse_ret("GFlags", GFlagsReturn) - -class GFlagsParam(IntParam): - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=( - "py_%s = pyg_flags_from_gtype(%s, %s);" % - (self.name, self.props['typecode'], self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name), - failure_expression=("!py_%s" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse("GFlags", GFlagsParam) - - -class GtkTreePathParam(IntParam): - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=( - "py_%s = pygtk_tree_path_to_pyobject(%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name), - failure_expression=("!py_%s" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse("GtkTreePath*", GtkTreePathParam) - - -class GtkTreePathReturn(ReturnType): - def get_c_type(self): - return self.props.get('c_type', 'GtkTreePath *') - def write_decl(self): - self.wrapper.add_declaration("GtkTreePath * retval;") - def write_error_return(self): - self.wrapper.write_code("return NULL;") - def write_conversion(self): - self.wrapper.write_code( - "retval = pygtk_tree_path_from_pyobject(py_retval);\n", - failure_expression=('!retval'), - failure_exception=( - 'PyErr_SetString(PyExc_TypeError, "retval should be a GtkTreePath");')) - -argtypes.matcher.register_reverse_ret("GtkTreePath*", GtkTreePathReturn) - - -class BooleanReturn(ReturnType): - def get_c_type(self): - return "gboolean" - def write_decl(self): - self.wrapper.add_declaration("gboolean retval;") - self.wrapper.add_declaration("PyObject *py_main_retval;") - def write_error_return(self): - self.wrapper.write_code("return FALSE;") - def write_conversion(self): - self.wrapper.add_pyret_parse_item("O", "&py_main_retval", prepend=True) - self.wrapper.write_code( - "retval = PyObject_IsTrue(py_main_retval)? TRUE : FALSE;", - code_sink=self.wrapper.post_return_code) -argtypes.matcher.register_reverse_ret("gboolean", BooleanReturn) - -class BooleanParam(Parameter): - def get_c_type(self): - return "gboolean" - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code("py_%s = %s? Py_True : Py_False;" - % (self.name, self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse("gboolean", BooleanParam) - - -class DoubleParam(Parameter): - def get_c_type(self): - return self.props.get('c_type', 'gdouble') - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = PyFloat_FromDouble(%s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -class DoublePtrParam(Parameter): - def __init__(self, wrapper, name, **props): - if "direction" not in props: - raise argtypes.ArgTypeConfigurationError( - "cannot use double* parameter without direction") - if props["direction"] not in ("out", ): # inout not yet implemented - raise argtypes.ArgTypeConfigurationError( - "cannot use double* parameter with direction '%s'" - % (props["direction"],)) - Parameter.__init__(self, wrapper, name, **props) - def get_c_type(self): - return self.props.get('c_type', 'double*') - def convert_c2py(self): - self.wrapper.add_pyret_parse_item("d", self.name) -for argtype in ('double*', 'gdouble*'): - argtypes.matcher.register_reverse(argtype, DoublePtrParam) -del argtype - -class DoubleReturn(ReturnType): - def get_c_type(self): - return self.props.get('c_type', 'gdouble') - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - def write_error_return(self): - self.wrapper.write_code("return -G_MAXFLOAT;") - def write_conversion(self): - self.wrapper.add_pyret_parse_item("d", "&retval", prepend=True) - -for argtype in ('float', 'double', 'gfloat', 'gdouble'): - argtypes.matcher.register_reverse(argtype, DoubleParam) - argtypes.matcher.register_reverse_ret(argtype, DoubleReturn) - - -class GBoxedParam(Parameter): - def get_c_type(self): - return self.props.get('c_type').replace('const-', 'const ') - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - ctype = self.get_c_type() - if ctype.startswith('const '): - ctype_no_const = ctype[len('const '):] - self.wrapper.write_code( - code=('py_%s = pyg_boxed_new(%s, (%s) %s, TRUE, TRUE);' % - (self.name, self.props['typecode'], - ctype_no_const, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - else: - self.wrapper.write_code( - code=('py_%s = pyg_boxed_new(%s, %s, FALSE, FALSE);' % - (self.name, self.props['typecode'], self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse("GBoxed", GBoxedParam) - - -class GBoxedReturn(ReturnType): - def get_c_type(self): - return self.props.get('c_type') - def write_decl(self): - self.wrapper.add_declaration("%s retval;" % self.get_c_type()) - def write_error_return(self): - self.wrapper.write_code("return retval;") - def write_conversion(self): - self.wrapper.write_code(code = None, - failure_expression=("!pyg_boxed_check(py_retval, %s)" % - (self.props['typecode'],)), - failure_exception=( - 'PyErr_SetString(PyExc_TypeError, "retval should be a %s");' - % (self.props['typename'],))) - self.wrapper.write_code('retval = pyg_boxed_get(py_retval, %s);' % - self.props['typename']) - -argtypes.matcher.register_reverse_ret("GBoxed", GBoxedReturn) - - -class GdkRegionPtrReturn(GBoxedReturn): - def write_error_return(self): - self.wrapper.write_code("return gdk_region_new();") - def write_conversion(self): - self.props['typecode'] = 'PYGDK_TYPE_REGION' - self.props['typename'] = 'GdkRegion' - super(GdkRegionPtrReturn, self).write_conversion() - -argtypes.matcher.register_reverse_ret("GdkRegion*", GdkRegionPtrReturn) - - -class PangoFontDescriptionReturn(GBoxedReturn): - def write_error_return(self): - self.wrapper.write_code("return pango_font_description_new();") - def write_conversion(self): - self.props['typecode'] = 'PANGO_TYPE_FONT_DESCRIPTION' - self.props['typename'] = 'PangoFontDescription' - super(PangoFontDescriptionReturn, self).write_conversion() - -argtypes.matcher.register_reverse_ret("PangoFontDescription*", - PangoFontDescriptionReturn) - - -class PangoFontMetricsReturn(GBoxedReturn): - def write_error_return(self): - self.wrapper.write_code("return pango_font_metrics_new();") - def write_conversion(self): - self.props['typecode'] = 'PANGO_TYPE_FONT_METRICS' - self.props['typename'] = 'PangoFontMetrics' - super(PangoFontMetricsReturn, self).write_conversion() - -argtypes.matcher.register_reverse_ret("PangoFontMetrics*", - PangoFontMetricsReturn) - - -class PangoLanguageReturn(GBoxedReturn): - def write_error_return(self): - self.wrapper.write_code("return pango_language_from_string(\"\");") - def write_conversion(self): - self.props['typecode'] = 'PANGO_TYPE_LANGUAGE' - self.props['typename'] = 'PangoLanguage' - super(PangoLanguageReturn, self).write_conversion() - -argtypes.matcher.register_reverse_ret("PangoLanguage*", PangoLanguageReturn) - - -class GdkRectanglePtrParam(Parameter): - def get_c_type(self): - return self.props.get('c_type').replace('const-', 'const ') - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code( - code=('py_%s = pyg_boxed_new(GDK_TYPE_RECTANGLE, %s, TRUE, TRUE);' % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name)) - self.wrapper.add_pyargv_item("py_%s" % self.name) - -argtypes.matcher.register_reverse("GdkRectangle*", GdkRectanglePtrParam) -argtypes.matcher.register_reverse('GtkAllocation*', GdkRectanglePtrParam) - - -class GErrorParam(Parameter): - def get_c_type(self): - return self.props.get('c_type').replace('**', ' **') - def convert_c2py(self): - self.wrapper.write_code(code=None, - failure_expression=("pyg_gerror_exception_check(%s)" % self.name), - code_sink=self.wrapper.check_exception_code) - -argtypes.matcher.register_reverse('GError**', GErrorParam) - - -class PyGObjectMethodParam(Parameter): - def __init__(self, wrapper, name, method_name, **props): - Parameter.__init__(self, wrapper, name, **props) - self.method_name = method_name - - def get_c_type(self): - return self.props.get('c_type', 'GObject *') - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject *py_%s;" % self.name) - self.wrapper.write_code(code=("py_%s = pygobject_new((GObject *) %s);" % - (self.name, self.name)), - cleanup=("Py_DECREF(py_%s);" % self.name), - failure_expression=("!py_%s" % self.name)) - self.wrapper.set_call_target("py_%s" % self.name, self.method_name) - - -class CallbackInUserDataParam(Parameter): - def __init__(self, wrapper, name, free_it, **props): - Parameter.__init__(self, wrapper, name, **props) - self.free_it = free_it - - def get_c_type(self): - return "gpointer" - - def convert_c2py(self): - self.wrapper.add_declaration("PyObject **_user_data;") - cleanup = self.free_it and ("g_free(%s);" % self.name) or None - self.wrapper.write_code(code=("_real_user_data = (PyObject **) %s;" - % self.name), - cleanup=cleanup) - - self.wrapper.add_declaration("PyObject *py_func;") - cleanup = self.free_it and "Py_DECREF(py_func);" or None - self.wrapper.write_code(code="py_func = _user_data[0];", - cleanup=cleanup) - self.wrapper.set_call_target("py_func") - - self.wrapper.add_declaration("PyObject *py_user_data;") - cleanup = self.free_it and "Py_XDECREF(py_user_data);" or None - self.wrapper.write_code(code="py_user_data = _user_data[1];", - cleanup=cleanup) - self.wrapper.add_pyargv_item("py_user_data", optional=True) - -def _test(): - import sys - - if 1: - wrapper = ReverseWrapper("this_is_the_c_function_name", is_static=True) - wrapper.set_return_type(StringReturn(wrapper)) - wrapper.add_parameter(PyGObjectMethodParam(wrapper, "self", method_name="do_xxx")) - wrapper.add_parameter(StringParam(wrapper, "param2", optional=True)) - wrapper.add_parameter(GObjectParam(wrapper, "param3")) - #wrapper.add_parameter(InoutIntParam(wrapper, "param4")) - wrapper.generate(FileCodeSink(sys.stderr)) - - if 0: - wrapper = ReverseWrapper("this_a_callback_wrapper") - wrapper.set_return_type(VoidReturn(wrapper)) - wrapper.add_parameter(StringParam(wrapper, "param1", optional=False)) - wrapper.add_parameter(GObjectParam(wrapper, "param2")) - wrapper.add_parameter(CallbackInUserDataParam(wrapper, "data", free_it=True)) - wrapper.generate(FileCodeSink(sys.stderr)) - -if __name__ == '__main__': - _test() diff --git a/bindings/python/codegen/scmexpr.py b/bindings/python/codegen/scmexpr.py deleted file mode 100755 index 02f2e4bf23..0000000000 --- a/bindings/python/codegen/scmexpr.py +++ /dev/null @@ -1,143 +0,0 @@ -#!/usr/bin/env python -# -*- Mode: Python; py-indent-offset: 4 -*- -from __future__ import generators - -import string -from cStringIO import StringIO - -class error(Exception): - def __init__(self, filename, lineno, msg): - Exception.__init__(self, msg) - self.filename = filename - self.lineno = lineno - self.msg = msg - def __str__(self): - return '%s:%d: error: %s' % (self.filename, self.lineno, self.msg) - -trans = [' '] * 256 -for i in range(256): - if chr(i) in string.letters + string.digits + '_': - trans[i] = chr(i) - else: - trans[i] = '_' -trans = string.join(trans, '') - -def parse(filename): - if isinstance(filename, str): - fp = open(filename, 'r') - else: # if not string, assume it is some kind of iterator - fp = filename - filename = getattr(fp, 'name', '') - whitespace = ' \t\n\r\x0b\x0c' - nonsymbol = whitespace + '();\'"' - stack = [] - openlines = [] - lineno = 0 - for line in fp: - pos = 0 - lineno += 1 - while pos < len(line): - if line[pos] in whitespace: # ignore whitespace - pass - elif line[pos] == ';': # comment - break - elif line[pos:pos+2] == "'(": - pass # the open parenthesis will be handled next iteration - elif line[pos] == '(': - stack.append(()) - openlines.append(lineno) - elif line[pos] == ')': - if len(stack) == 0: - raise error(filename, lineno, 'close parenthesis found when none open') - closed = stack[-1] - del stack[-1] - del openlines[-1] - if stack: - stack[-1] += (closed,) - else: - yield closed - elif line[pos] == '"': # quoted string - if not stack: - raise error(filename, lineno, - 'string found outside of s-expression') - endpos = pos + 1 - chars = [] - while endpos < len(line): - if endpos+1 < len(line) and line[endpos] == '\\': - endpos += 1 - if line[endpos] == 'n': - chars.append('\n') - elif line[endpos] == 'r': - chars.append('\r') - elif line[endpos] == 't': - chars.append('\t') - else: - chars.append('\\') - chars.append(line[endpos]) - elif line[endpos] == '"': - break - else: - chars.append(line[endpos]) - endpos += 1 - if endpos >= len(line): - raise error(filename, lineno, "unclosed quoted string") - pos = endpos - stack[-1] += (''.join(chars),) - else: # symbol/number - if not stack: - raise error(filename, lineno, - 'identifier found outside of s-expression') - endpos = pos - while endpos < len(line) and line[endpos] not in nonsymbol: - endpos += 1 - symbol = line[pos:endpos] - pos = max(pos, endpos-1) - try: symbol = int(symbol) - except ValueError: - try: symbol = float(symbol) - except ValueError: pass - stack[-1] += (symbol,) - pos += 1 - if len(stack) != 0: - msg = '%d unclosed parentheses found at end of ' \ - 'file (opened on line(s) %s)' % (len(stack), - ', '.join(map(str, openlines))) - raise error(filename, lineno, msg) - -class Parser: - def __init__(self, filename): - """Argument is either a string, a parse tree, or file object""" - self.filename = filename - def startParsing(self, filename=None): - statements = parse(filename or self.filename) - for statement in statements: - self.handle(statement) - def handle(self, tup): - cmd = string.translate(tup[0], trans) - if hasattr(self, cmd): - getattr(self, cmd)(*tup[1:]) - else: - self.unknown(tup) - def unknown(self, tup): - pass - -_testString = """; a scheme file -(define-func gdk_font_load ; a comment at end of line - GdkFont - ((string name))) - -(define-boxed GdkEvent - gdk_event_copy - gdk_event_free - "sizeof(GdkEvent)") -""" - -if __name__ == '__main__': - import sys - if sys.argv[1:]: - fp = open(sys.argv[1]) - else: - fp = StringIO(_testString) - statements = parse(fp) - for s in statements: - print `s` diff --git a/bindings/python/examples/Makefile.am b/bindings/python/examples/Makefile.am deleted file mode 100644 index 115afa7376..0000000000 --- a/bindings/python/examples/Makefile.am +++ /dev/null @@ -1,7 +0,0 @@ -examplesdir = $(pkgdatadir)/$(GST_MAJORMINOR)/examples - -examples_DATA = \ - simple.py - effect.py - -EXTRA_DIST = $(examples_DATA) diff --git a/bindings/python/examples/effect.py b/bindings/python/examples/effect.py deleted file mode 100755 index fc3f82d8a7..0000000000 --- a/bindings/python/examples/effect.py +++ /dev/null @@ -1,100 +0,0 @@ -#!/usr/bin/env python -# -# effect.py -# -# Copyright (C) 2011 Mathieu Duponchelle -# Copyright (C) 2011 Luis de Bethencourt -# -# This program is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this program; if not, write to the -# Free Software Foundation, Inc., 59 Temple Place - Suite 330, -# Boston, MA 02111-1307, USA. -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. - -import sys -import optparse - -import glib -import gobject -gobject.threads_init() - -import gst -import ges - -class Effect: - def __init__(self, effects): - ges.init() - self.mainloop = glib.MainLoop() - - self.timeline = ges.timeline_new_audio_video() - layer = ges.TimelineLayer() - self.src = ges.TimelineTestSource() - self.src.set_start(long(0)) - - self.src.set_duration(long(3000000000)) - self.src.set_vpattern("smpte75") - layer.add_object(self.src) - self.timeline.add_layer(layer) - - self.add_effects(effects) - - self.pipeline = ges.TimelinePipeline() - self.pipeline.add_timeline(self.timeline) - bus = self.pipeline.get_bus() - bus.set_sync_handler(self.bus_handler) - - def add_effects(self, effects): - for e in effects: - effect = ges.TrackParseLaunchEffect(e) - self.src.add_track_object(effect) - for track in self.timeline.get_tracks(): - if track.get_caps().to_string() == \ - "video/x-raw-yuv; video/x-raw-rgb": - print "setting effect: " + e - track.add_object(effect) - - def bus_handler(self, unused_bus, message): - if message.type == gst.MESSAGE_ERROR: - print "ERROR" - self.mainloop.quit() - elif message.type == gst.MESSAGE_EOS: - print "Done" - self.mainloop.quit() - - return gst.BUS_PASS - - def run(self): - if (self.pipeline.set_state(gst.STATE_PLAYING) == \ - gst.STATE_CHANGE_FAILURE): - print "Couldn't start pipeline" - - self.mainloop.run() - -def main(args): - usage = "usage: %s effect_name-1 .. effect_name-n\n" % args[0] - - if len(args) < 2: - print usage + "using aging tv as a default instead" - args.append("agingtv") - - parser = optparse.OptionParser (usage=usage) - (opts, args) = parser.parse_args () - - effect = Effect(args) - effect.run() - -if __name__ == "__main__": - main(sys.argv) diff --git a/bindings/python/examples/simple.py b/bindings/python/examples/simple.py deleted file mode 100755 index ec6b1c1708..0000000000 --- a/bindings/python/examples/simple.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env python -# -# simple.py -# -# Copyright (C) 2011 Thibault Saunier -# Copyright (C) 2011 Luis de Bethencourt -# -# This program is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this program; if not, write to the -# Free Software Foundation, Inc., 59 Temple Place - Suite 330, -# Boston, MA 02111-1307, USA. -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. - -import sys -import optparse - -import glib -import gobject -gobject.threads_init() - -import gst -import ges - -class Simple: - def __init__(self, uris): - # init ges to have debug logs - ges.init() - self.mainloop = glib.MainLoop() - - timeline = ges.timeline_new_audio_video() - self.layer = ges.SimpleTimelineLayer() - timeline.add_layer(self.layer) - - self.pipeline = ges.TimelinePipeline() - self.pipeline.add_timeline(timeline) - bus = self.pipeline.get_bus() - bus.set_sync_handler(self.bus_handler) - - # all timeline objects except the last will have a transition at the end - for n in uris[:-1]: - self.add_timeline_object(n, True) - self.add_timeline_object(uris[-1], False) - - def add_timeline_object(self, uri, do_transition): - filesource = ges.TimelineFileSource (uri) - filesource.set_duration(long (gst.SECOND * 5)) - self.layer.add_object(filesource, -1) - - if do_transition: - transition = ges.TimelineStandardTransition("crossfade") - transition.duration = gst.SECOND * 2 - self.layer.add_object(transition, -1) - - def bus_handler(self, unused_bus, message): - if message.type == gst.MESSAGE_ERROR: - print "ERROR" - self.mainloop.quit() - elif message.type == gst.MESSAGE_EOS: - print "Done" - self.mainloop.quit() - - return gst.BUS_PASS - - def run(self): - if (self.pipeline.set_state(gst.STATE_PLAYING) == \ - gst.STATE_CHANGE_FAILURE): - print "Couldn't start pipeline" - - self.mainloop.run() - - -def main(args): - usage = "usage: %s URI-OF-VIDEO-1 ... URI-OF-VIDEO-n\n" % args[0] - - if len(args) < 2: - sys.stderr.write(usage) - sys.exit(1) - - parser = optparse.OptionParser (usage=usage) - (options, args) = parser.parse_args () - - simple = Simple(args) - simple.run() - -if __name__ == "__main__": - sys.exit(main(sys.argv)) diff --git a/bindings/python/ges-types.defs b/bindings/python/ges-types.defs deleted file mode 100644 index 50dc4b94d5..0000000000 --- a/bindings/python/ges-types.defs +++ /dev/null @@ -1,391 +0,0 @@ -;; -*- scheme -*- -; object definitions ... -(define-object Formatter - (in-module "GES") - (parent "GObject") - (c-name "GESFormatter") - (gtype-id "GES_TYPE_FORMATTER") -) - -(define-object KeyfileFormatter - (in-module "GES") - (parent "GESFormatter") - (c-name "GESKeyfileFormatter") - (gtype-id "GES_TYPE_KEYFILE_FORMATTER") -) - -(define-object Timeline - (in-module "GES") - (parent "GstBin") - (c-name "GESTimeline") - (gtype-id "GES_TYPE_TIMELINE") -) - -(define-object TimelineLayer - (in-module "GES") - (parent "GInitiallyUnowned") - (c-name "GESTimelineLayer") - (gtype-id "GES_TYPE_TIMELINE_LAYER") -) - -(define-object SimpleTimelineLayer - (in-module "GES") - (parent "GESTimelineLayer") - (c-name "GESSimpleTimelineLayer") - (gtype-id "GES_TYPE_SIMPLE_TIMELINE_LAYER") -) - -(define-object TimelineObject - (in-module "GES") - (parent "GInitiallyUnowned") - (c-name "GESTimelineObject") - (gtype-id "GES_TYPE_TIMELINE_OBJECT") -) - -(define-object TimelineOperation - (in-module "GES") - (parent "GESTimelineObject") - (c-name "GESTimelineOperation") - (gtype-id "GES_TYPE_TIMELINE_OPERATION") -) - -(define-object TimelineEffect - (in-module "GES") - (parent "GESTimelineOperation") - (c-name "GESTimelineEffect") - (gtype-id "GES_TYPE_TIMELINE_EFFECT") -) - -(define-object TimelineOverlay - (in-module "GES") - (parent "GESTimelineOperation") - (c-name "GESTimelineOverlay") - (gtype-id "GES_TYPE_TIMELINE_OVERLAY") -) - -(define-object TimelineParseLaunchEffect - (in-module "GES") - (parent "GESTimelineEffect") - (c-name "GESTimelineParseLaunchEffect") - (gtype-id "GES_TYPE_TIMELINE_PARSE_LAUNCH_EFFECT") -) - -(define-object TimelinePipeline - (in-module "GES") - (parent "GstPipeline") - (c-name "GESTimelinePipeline") - (gtype-id "GES_TYPE_TIMELINE_PIPELINE") -) - -(define-object TimelineSource - (in-module "GES") - (parent "GESTimelineObject") - (c-name "GESTimelineSource") - (gtype-id "GES_TYPE_TIMELINE_SOURCE") -) - -(define-object TimelineFileSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESTimelineFileSource") - (gtype-id "GES_TYPE_TIMELINE_FILE_SOURCE") -) - -(define-object CustomTimelineSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESCustomTimelineSource") - (gtype-id "GES_TYPE_CUSTOM_TIMELINE_SOURCE") -) - -(define-object TimelineTestSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESTimelineTestSource") - (gtype-id "GES_TYPE_TIMELINE_TEST_SOURCE") -) - -(define-object TimelineTextOverlay - (in-module "GES") - (parent "GESTimelineOverlay") - (c-name "GESTimelineTextOverlay") - (gtype-id "GES_TYPE_TIMELINE_TEXT_OVERLAY") -) - -(define-object TimelineTitleSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESTimelineTitleSource") - (gtype-id "GES_TYPE_TIMELINE_TITLE_SOURCE") -) - -(define-object TimelineTransition - (in-module "GES") - (parent "GESTimelineOperation") - (c-name "GESTimelineTransition") - (gtype-id "GES_TYPE_TIMELINE_TRANSITION") -) - -(define-object TimelineStandardTransition - (in-module "GES") - (parent "GESTimelineTransition") - (c-name "GESTimelineStandardTransition") - (gtype-id "GES_TYPE_TIMELINE_STANDARD_TRANSITION") -) - -(define-object Track - (in-module "GES") - (parent "GstBin") - (c-name "GESTrack") - (gtype-id "GES_TYPE_TRACK") -) - -(define-object TrackObject - (in-module "GES") - (parent "GInitiallyUnowned") - (c-name "GESTrackObject") - (gtype-id "GES_TYPE_TRACK_OBJECT") -) - -(define-object TrackOperation - (in-module "GES") - (parent "GESTrackObject") - (c-name "GESTrackOperation") - (gtype-id "GES_TYPE_TRACK_OPERATION") -) - -(define-object TrackEffect - (in-module "GES") - (parent "GESTrackOperation") - (c-name "GESTrackEffect") - (gtype-id "GES_TYPE_TRACK_EFFECT") -) - -(define-object TrackParseLaunchEffect - (in-module "GES") - (parent "GESTrackEffect") - (c-name "GESTrackParseLaunchEffect") - (gtype-id "GES_TYPE_TRACK_PARSE_LAUNCH_EFFECT") -) - -(define-object TrackSource - (in-module "GES") - (parent "GESTrackObject") - (c-name "GESTrackSource") - (gtype-id "GES_TYPE_TRACK_SOURCE") -) - -(define-object TrackImageSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackImageSource") - (gtype-id "GES_TYPE_TRACK_IMAGE_SOURCE") -) - -(define-object TrackFileSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackFileSource") - (gtype-id "GES_TYPE_TRACK_FILE_SOURCE") -) - -(define-object TrackAudioTestSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackAudioTestSource") - (gtype-id "GES_TYPE_TRACK_AUDIO_TEST_SOURCE") -) - -(define-object TrackTextOverlay - (in-module "GES") - (parent "GESTrackOperation") - (c-name "GESTrackTextOverlay") - (gtype-id "GES_TYPE_TRACK_TEXT_OVERLAY") -) - -(define-object TrackTitleSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackTitleSource") - (gtype-id "GES_TYPE_TRACK_TITLE_SOURCE") -) - -(define-object TrackTransition - (in-module "GES") - (parent "GESTrackOperation") - (c-name "GESTrackTransition") - (gtype-id "GES_TYPE_TRACK_TRANSITION") -) - -(define-object TrackAudioTransition - (in-module "GES") - (parent "GESTrackTransition") - (c-name "GESTrackAudioTransition") - (gtype-id "GES_TYPE_TRACK_AUDIO_TRANSITION") -) - -(define-object TrackVideoTestSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackVideoTestSource") - (gtype-id "GES_TYPE_TRACK_VIDEO_TEST_SOURCE") -) - -(define-object TrackVideoTransition - (in-module "GES") - (parent "GESTrackTransition") - (c-name "GESTrackVideoTransition") - (gtype-id "GES_TYPE_TRACK_VIDEO_TRANSITION") -) - -;; Enumerations and flags ... - -(define-flags TrackType - (in-module "GES") - (c-name "GESTrackType") - (gtype-id "GES_TYPE_TRACK_TYPE") - (values - '("unknown" "GES_TRACK_TYPE_UNKNOWN") - '("audio" "GES_TRACK_TYPE_AUDIO") - '("video" "GES_TRACK_TYPE_VIDEO") - '("text" "GES_TRACK_TYPE_TEXT") - '("custom" "GES_TRACK_TYPE_CUSTOM") - ) -) - -(define-enum VideoStandardTransitionType - (in-module "GES") - (c-name "GESVideoStandardTransitionType") - (gtype-id "GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE") - (values - '("none" "GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE") - '("bar-wipe-lr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR") - '("bar-wipe-tb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB") - '("box-wipe-tl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL") - '("box-wipe-tr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR") - '("box-wipe-br" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR") - '("box-wipe-bl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL") - '("four-box-wipe-ci" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI") - '("four-box-wipe-co" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO") - '("barndoor-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V") - '("barndoor-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H") - '("box-wipe-tc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC") - '("box-wipe-rc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC") - '("box-wipe-bc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC") - '("box-wipe-lc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC") - '("diagonal-tl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL") - '("diagonal-tr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR") - '("bowtie-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V") - '("bowtie-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H") - '("barndoor-dbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL") - '("barndoor-dtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL") - '("misc-diagonal-dbd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD") - '("misc-diagonal-dd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD") - '("vee-d" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D") - '("vee-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L") - '("vee-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U") - '("vee-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R") - '("barnvee-d" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D") - '("barnvee-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L") - '("barnvee-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U") - '("barnvee-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R") - '("iris-rect" "GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT") - '("clock-cw12" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12") - '("clock-cw3" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3") - '("clock-cw6" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6") - '("clock-cw9" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9") - '("pinwheel-tbv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV") - '("pinwheel-tbh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH") - '("pinwheel-fb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB") - '("fan-ct" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT") - '("fan-cr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR") - '("doublefan-fov" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV") - '("doublefan-foh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH") - '("singlesweep-cwt" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT") - '("singlesweep-cwr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR") - '("singlesweep-cwb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB") - '("singlesweep-cwl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL") - '("doublesweep-pv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV") - '("doublesweep-pd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD") - '("doublesweep-ov" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV") - '("doublesweep-oh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH") - '("fan-t" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T") - '("fan-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R") - '("fan-b" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B") - '("fan-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L") - '("doublefan-fiv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV") - '("doublefan-fih" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH") - '("singlesweep-cwtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL") - '("singlesweep-cwbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL") - '("singlesweep-cwbr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR") - '("singlesweep-cwtr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR") - '("doublesweep-pdtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL") - '("doublesweep-pdbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL") - '("saloondoor-t" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T") - '("saloondoor-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L") - '("saloondoor-b" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B") - '("saloondoor-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R") - '("windshield-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R") - '("windshield-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U") - '("windshield-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V") - '("windshield-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H") - '("crossfade" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE") - ) -) - -(define-enum TextVAlign - (in-module "GES") - (c-name "GESTextVAlign") - (gtype-id "GES_TEXT_VALIGN_TYPE") - (values - '("baseline" "GES_TEXT_VALIGN_BASELINE") - '("bottom" "GES_TEXT_VALIGN_BOTTOM") - '("top" "GES_TEXT_VALIGN_TOP") - ) -) - -(define-enum TextHAlign - (in-module "GES") - (c-name "GESTextHAlign") - (gtype-id "GES_TEXT_HALIGN_TYPE") - (values - '("left" "GES_TEXT_HALIGN_LEFT") - '("center" "GES_TEXT_HALIGN_CENTER") - '("right" "GES_TEXT_HALIGN_RIGHT") - ) -) - -(define-enum VideoTestPattern - (in-module "GES") - (c-name "GESVideoTestPattern") - (gtype-id "GES_VIDEO_TEST_PATTERN_TYPE") - (values - '("smpte" "GES_VIDEO_TEST_PATTERN_SMPTE") - '("snow" "GES_VIDEO_TEST_PATTERN_SNOW") - '("black" "GES_VIDEO_TEST_PATTERN_BLACK") - '("white" "GES_VIDEO_TEST_PATTERN_WHITE") - '("red" "GES_VIDEO_TEST_PATTERN_RED") - '("green" "GES_VIDEO_TEST_PATTERN_GREEN") - '("blue" "GES_VIDEO_TEST_PATTERN_BLUE") - '("checkers1" "GES_VIDEO_TEST_PATTERN_CHECKERS1") - '("checkers2" "GES_VIDEO_TEST_PATTERN_CHECKERS2") - '("checkers4" "GES_VIDEO_TEST_PATTERN_CHECKERS4") - '("checkers8" "GES_VIDEO_TEST_PATTERN_CHECKERS8") - '("circular" "GES_VIDEO_TEST_PATTERN_CIRCULAR") - '("blink" "GES_VIDEO_TEST_PATTERN_BLINK") - '("smpte75" "GES_VIDEO_TEST_PATTERN_SMPTE75") - ) -) - -(define-flags PipelineFlags - (in-module "GES") - (c-name "GESPipelineFlags") - (gtype-id "GES_TYPE_PIPELINE_FLAGS") - (values - '("preview-audio" "TIMELINE_MODE_PREVIEW_AUDIO") - '("preview-video" "TIMELINE_MODE_PREVIEW_VIDEO") - '("preview" "TIMELINE_MODE_PREVIEW") - '("render" "TIMELINE_MODE_RENDER") - '("smart-render" "TIMELINE_MODE_SMART_RENDER") - ) -) diff --git a/bindings/python/ges.defs b/bindings/python/ges.defs deleted file mode 100644 index c6c2701355..0000000000 --- a/bindings/python/ges.defs +++ /dev/null @@ -1,2111 +0,0 @@ -;; -*- scheme -*- -; object definitions ... -(define-object Formatter - (in-module "GES") - (parent "GObject") - (c-name "GESFormatter") - (gtype-id "GES_TYPE_FORMATTER") -) - -(define-object KeyfileFormatter - (in-module "GES") - (parent "GESFormatter") - (c-name "GESKeyfileFormatter") - (gtype-id "GES_TYPE_KEYFILE_FORMATTER") -) - -(define-object Timeline - (in-module "GES") - (parent "GstBin") - (c-name "GESTimeline") - (gtype-id "GES_TYPE_TIMELINE") -) - -(define-object TimelineLayer - (in-module "GES") - (parent "GInitiallyUnowned") - (c-name "GESTimelineLayer") - (gtype-id "GES_TYPE_TIMELINE_LAYER") -) - -(define-object SimpleTimelineLayer - (in-module "GES") - (parent "GESTimelineLayer") - (c-name "GESSimpleTimelineLayer") - (gtype-id "GES_TYPE_SIMPLE_TIMELINE_LAYER") -) - -(define-object TimelineObject - (in-module "GES") - (parent "GInitiallyUnowned") - (c-name "GESTimelineObject") - (gtype-id "GES_TYPE_TIMELINE_OBJECT") -) - -(define-object TimelineOperation - (in-module "GES") - (parent "GESTimelineObject") - (c-name "GESTimelineOperation") - (gtype-id "GES_TYPE_TIMELINE_OPERATION") -) - -(define-object TimelineEffect - (in-module "GES") - (parent "GESTimelineOperation") - (c-name "GESTimelineEffect") - (gtype-id "GES_TYPE_TIMELINE_EFFECT") -) - -(define-object TimelineOverlay - (in-module "GES") - (parent "GESTimelineOperation") - (c-name "GESTimelineOverlay") - (gtype-id "GES_TYPE_TIMELINE_OVERLAY") -) - -(define-object TimelineParseLaunchEffect - (in-module "GES") - (parent "GESTimelineEffect") - (c-name "GESTimelineParseLaunchEffect") - (gtype-id "GES_TYPE_TIMELINE_PARSE_LAUNCH_EFFECT") -) - -(define-object TimelinePipeline - (in-module "GES") - (parent "GstPipeline") - (c-name "GESTimelinePipeline") - (gtype-id "GES_TYPE_TIMELINE_PIPELINE") -) - -(define-object TimelineSource - (in-module "GES") - (parent "GESTimelineObject") - (c-name "GESTimelineSource") - (gtype-id "GES_TYPE_TIMELINE_SOURCE") -) - -(define-object TimelineFileSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESTimelineFileSource") - (gtype-id "GES_TYPE_TIMELINE_FILE_SOURCE") -) - -(define-object CustomTimelineSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESCustomTimelineSource") - (gtype-id "GES_TYPE_CUSTOM_TIMELINE_SOURCE") -) - -(define-object TimelineTestSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESTimelineTestSource") - (gtype-id "GES_TYPE_TIMELINE_TEST_SOURCE") -) - -(define-object TimelineTextOverlay - (in-module "GES") - (parent "GESTimelineOverlay") - (c-name "GESTimelineTextOverlay") - (gtype-id "GES_TYPE_TIMELINE_TEXT_OVERLAY") -) - -(define-object TimelineTitleSource - (in-module "GES") - (parent "GESTimelineSource") - (c-name "GESTimelineTitleSource") - (gtype-id "GES_TYPE_TIMELINE_TITLE_SOURCE") -) - -(define-object TimelineTransition - (in-module "GES") - (parent "GESTimelineOperation") - (c-name "GESTimelineTransition") - (gtype-id "GES_TYPE_TIMELINE_TRANSITION") -) - -(define-object TimelineStandardTransition - (in-module "GES") - (parent "GESTimelineTransition") - (c-name "GESTimelineStandardTransition") - (gtype-id "GES_TYPE_TIMELINE_STANDARD_TRANSITION") -) - -(define-object Track - (in-module "GES") - (parent "GstBin") - (c-name "GESTrack") - (gtype-id "GES_TYPE_TRACK") -) - -(define-object TrackObject - (in-module "GES") - (parent "GInitiallyUnowned") - (c-name "GESTrackObject") - (gtype-id "GES_TYPE_TRACK_OBJECT") -) - -(define-object TrackOperation - (in-module "GES") - (parent "GESTrackObject") - (c-name "GESTrackOperation") - (gtype-id "GES_TYPE_TRACK_OPERATION") -) - -(define-object TrackEffect - (in-module "GES") - (parent "GESTrackOperation") - (c-name "GESTrackEffect") - (gtype-id "GES_TYPE_TRACK_EFFECT") -) - -(define-object TrackParseLaunchEffect - (in-module "GES") - (parent "GESTrackEffect") - (c-name "GESTrackParseLaunchEffect") - (gtype-id "GES_TYPE_TRACK_PARSE_LAUNCH_EFFECT") -) - -(define-object TrackSource - (in-module "GES") - (parent "GESTrackObject") - (c-name "GESTrackSource") - (gtype-id "GES_TYPE_TRACK_SOURCE") -) - -(define-object TrackImageSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackImageSource") - (gtype-id "GES_TYPE_TRACK_IMAGE_SOURCE") -) - -(define-object TrackFileSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackFileSource") - (gtype-id "GES_TYPE_TRACK_FILESOURCE") -) - -(define-object TrackAudioTestSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackAudioTestSource") - (gtype-id "GES_TYPE_TRACK_AUDIO_TEST_SOURCE") -) - -(define-object TrackTextOverlay - (in-module "GES") - (parent "GESTrackOperation") - (c-name "GESTrackTextOverlay") - (gtype-id "GES_TYPE_TRACK_TEXT_OVERLAY") -) - -(define-object TrackTitleSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackTitleSource") - (gtype-id "GES_TYPE_TRACK_TITLE_SOURCE") -) - -(define-object TrackTransition - (in-module "GES") - (parent "GESTrackOperation") - (c-name "GESTrackTransition") - (gtype-id "GES_TYPE_TRACK_TRANSITION") -) - -(define-object TrackAudioTransition - (in-module "GES") - (parent "GESTrackTransition") - (c-name "GESTrackAudioTransition") - (gtype-id "GES_TYPE_TRACK_AUDIO_TRANSITION") -) - -(define-object TrackVideoTestSource - (in-module "GES") - (parent "GESTrackSource") - (c-name "GESTrackVideoTestSource") - (gtype-id "GES_TYPE_TRACK_VIDEO_TEST_SOURCE") -) - -(define-object TrackVideoTransition - (in-module "GES") - (parent "GESTrackTransition") - (c-name "GESTrackVideoTransition") - (gtype-id "GES_TYPE_TRACK_VIDEO_TRANSITION") -) - -;; Enumerations and flags ... - -(define-flags TrackType - (in-module "GES") - (c-name "GESTrackType") - (gtype-id "GES_TYPE_TRACK_TYPE") - (values - '("unknown" "GES_TRACK_TYPE_UNKNOWN") - '("audio" "GES_TRACK_TYPE_AUDIO") - '("video" "GES_TRACK_TYPE_VIDEO") - '("text" "GES_TRACK_TYPE_TEXT") - '("custom" "GES_TRACK_TYPE_CUSTOM") - ) -) - -(define-enum VideoStandardTransitionType - (in-module "GES") - (c-name "GESVideoStandardTransitionType") - (gtype-id "GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE") - (values - '("none" "GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE") - '("bar-wipe-lr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR") - '("bar-wipe-tb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB") - '("box-wipe-tl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL") - '("box-wipe-tr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR") - '("box-wipe-br" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR") - '("box-wipe-bl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL") - '("four-box-wipe-ci" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI") - '("four-box-wipe-co" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO") - '("barndoor-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V") - '("barndoor-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H") - '("box-wipe-tc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC") - '("box-wipe-rc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC") - '("box-wipe-bc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC") - '("box-wipe-lc" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC") - '("diagonal-tl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL") - '("diagonal-tr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR") - '("bowtie-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V") - '("bowtie-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H") - '("barndoor-dbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL") - '("barndoor-dtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL") - '("misc-diagonal-dbd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD") - '("misc-diagonal-dd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD") - '("vee-d" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D") - '("vee-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L") - '("vee-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U") - '("vee-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R") - '("barnvee-d" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D") - '("barnvee-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L") - '("barnvee-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U") - '("barnvee-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R") - '("iris-rect" "GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT") - '("clock-cw12" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12") - '("clock-cw3" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3") - '("clock-cw6" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6") - '("clock-cw9" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9") - '("pinwheel-tbv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV") - '("pinwheel-tbh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH") - '("pinwheel-fb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB") - '("fan-ct" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT") - '("fan-cr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR") - '("doublefan-fov" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV") - '("doublefan-foh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH") - '("singlesweep-cwt" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT") - '("singlesweep-cwr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR") - '("singlesweep-cwb" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB") - '("singlesweep-cwl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL") - '("doublesweep-pv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV") - '("doublesweep-pd" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD") - '("doublesweep-ov" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV") - '("doublesweep-oh" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH") - '("fan-t" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T") - '("fan-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R") - '("fan-b" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B") - '("fan-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L") - '("doublefan-fiv" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV") - '("doublefan-fih" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH") - '("singlesweep-cwtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL") - '("singlesweep-cwbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL") - '("singlesweep-cwbr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR") - '("singlesweep-cwtr" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR") - '("doublesweep-pdtl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL") - '("doublesweep-pdbl" "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL") - '("saloondoor-t" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T") - '("saloondoor-l" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L") - '("saloondoor-b" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B") - '("saloondoor-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R") - '("windshield-r" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R") - '("windshield-u" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U") - '("windshield-v" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V") - '("windshield-h" "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H") - '("crossfade" "GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE") - ) -) - -(define-enum TextVAlign - (in-module "GES") - (c-name "GESTextVAlign") - (gtype-id "GES_TEXT_VALIGN_TYPE") - (values - '("baseline" "GES_TEXT_VALIGN_BASELINE") - '("bottom" "GES_TEXT_VALIGN_BOTTOM") - '("top" "GES_TEXT_VALIGN_TOP") - ) -) - -(define-enum TextHAlign - (in-module "GES") - (c-name "GESTextHAlign") - (gtype-id "GES_TEXT_HALIGN_TYPE") - (values - '("left" "GES_TEXT_HALIGN_LEFT") - '("center" "GES_TEXT_HALIGN_CENTER") - '("right" "GES_TEXT_HALIGN_RIGHT") - ) -) - -(define-enum VideoTestPattern - (in-module "GES") - (c-name "GESVideoTestPattern") - (gtype-id "GES_VIDEO_TEST_PATTERN_TYPE") - (values - '("smpte" "GES_VIDEO_TEST_PATTERN_SMPTE") - '("snow" "GES_VIDEO_TEST_PATTERN_SNOW") - '("black" "GES_VIDEO_TEST_PATTERN_BLACK") - '("white" "GES_VIDEO_TEST_PATTERN_WHITE") - '("red" "GES_VIDEO_TEST_PATTERN_RED") - '("green" "GES_VIDEO_TEST_PATTERN_GREEN") - '("blue" "GES_VIDEO_TEST_PATTERN_BLUE") - '("checkers1" "GES_VIDEO_TEST_PATTERN_CHECKERS1") - '("checkers2" "GES_VIDEO_TEST_PATTERN_CHECKERS2") - '("checkers4" "GES_VIDEO_TEST_PATTERN_CHECKERS4") - '("checkers8" "GES_VIDEO_TEST_PATTERN_CHECKERS8") - '("circular" "GES_VIDEO_TEST_PATTERN_CIRCULAR") - '("blink" "GES_VIDEO_TEST_PATTERN_BLINK") - '("smpte75" "GES_VIDEO_TEST_PATTERN_SMPTE75") - ) -) - -(define-flags PipelineFlags - (in-module "GES") - (c-name "GESPipelineFlags") - (gtype-id "GES_TYPE_PIPELINE_FLAGS") - (values - '("preview-audio" "TIMELINE_MODE_PREVIEW_AUDIO") - '("preview-video" "TIMELINE_MODE_PREVIEW_VIDEO") - '("preview" "TIMELINE_MODE_PREVIEW") - '("render" "TIMELINE_MODE_RENDER") - '("smart-render" "TIMELINE_MODE_SMART_RENDER") - ) -) - - -;; From ges-custom-timeline-source.h - -(define-function custom_timeline_source_get_type - (c-name "ges_custom_timeline_source_get_type") - (return-type "GType") -) - -(define-function custom_timeline_source_new - (c-name "ges_custom_timeline_source_new") - (is-constructor-of "GESCustomTimelineSource") - (return-type "GESCustomTimelineSource*") - (parameters - '("GESFillTrackObjectUserFunc" "func") - '("gpointer" "user_data") - ) -) - - - -;; From ges-enums.h - -(define-function track_type_get_type - (c-name "ges_track_type_get_type") - (return-type "GType") -) - -(define-function video_standard_transition_type_get_type - (c-name "ges_video_standard_transition_type_get_type") - (return-type "GType") -) - -(define-function text_valign_get_type - (c-name "ges_text_valign_get_type") - (return-type "GType") -) - -(define-function text_halign_get_type - (c-name "ges_text_halign_get_type") - (return-type "GType") -) - -(define-function video_test_pattern_get_type - (c-name "ges_video_test_pattern_get_type") - (return-type "GType") -) - -(define-function pipeline_flags_get_type - (c-name "ges_pipeline_flags_get_type") - (return-type "GType") -) - - - -;; From ges-formatter.h - -(define-function formatter_get_type - (c-name "ges_formatter_get_type") - (return-type "GType") -) - -(define-function formatter_new_for_uri - (c-name "ges_formatter_new_for_uri") - (return-type "GESFormatter*") - (parameters - '("const-gchar*" "uri") - ) -) - -(define-function default_formatter_new - (c-name "ges_default_formatter_new") - (is-constructor-of "GESDefaultFormatter") - (return-type "GESFormatter*") -) - -(define-function formatter_can_load_uri - (c-name "ges_formatter_can_load_uri") - (return-type "gboolean") - (parameters - '("const-gchar*" "uri") - ) -) - -(define-function formatter_can_save_uri - (c-name "ges_formatter_can_save_uri") - (return-type "gboolean") - (parameters - '("const-gchar*" "uri") - ) -) - -(define-method load_from_uri - (of-object "GESFormatter") - (c-name "ges_formatter_load_from_uri") - (return-type "gboolean") - (parameters - '("GESTimeline*" "timeline") - '("const-gchar*" "uri") - ) -) - -(define-method save_to_uri - (of-object "GESFormatter") - (c-name "ges_formatter_save_to_uri") - (return-type "gboolean") - (parameters - '("GESTimeline*" "timeline") - '("const-gchar*" "uri") - ) -) - -(define-method load - (of-object "GESFormatter") - (c-name "ges_formatter_load") - (return-type "gboolean") - (parameters - '("GESTimeline*" "timeline") - ) -) - -(define-method save - (of-object "GESFormatter") - (c-name "ges_formatter_save") - (return-type "gboolean") - (parameters - '("GESTimeline*" "timeline") - ) -) - -(define-method clear_data - (of-object "GESFormatter") - (c-name "ges_formatter_clear_data") - (return-type "none") -) - - - -;; From ges.h - -(define-function init - (c-name "ges_init") - (return-type "gboolean") -) - - - -;; From ges-internal.h - - - -;; From ges-keyfile-formatter.h - -(define-function keyfile_formatter_get_type - (c-name "ges_keyfile_formatter_get_type") - (return-type "GType") -) - -(define-function keyfile_formatter_new - (c-name "ges_keyfile_formatter_new") - (is-constructor-of "GESKeyfileFormatter") - (return-type "GESKeyfileFormatter*") -) - - - -;; From gesmarshal.h - - - -;; From ges-screenshot.h - -(define-function play_sink_convert_frame - (c-name "ges_play_sink_convert_frame") - (return-type "GstBuffer*") - (parameters - '("GstElement*" "playsink") - '("GstCaps*" "caps") - ) -) - - - -;; From ges-simple-timeline-layer.h - -(define-function simple_timeline_layer_get_type - (c-name "ges_simple_timeline_layer_get_type") - (return-type "GType") -) - -(define-function simple_timeline_layer_new - (c-name "ges_simple_timeline_layer_new") - (is-constructor-of "GESSimpleTimelineLayer") - (return-type "GESSimpleTimelineLayer*") -) - -(define-method add_object - (of-object "GESSimpleTimelineLayer") - (c-name "ges_simple_timeline_layer_add_object") - (return-type "gboolean") - (parameters - '("GESTimelineObject*" "object") - '("gint" "position") - ) -) - -(define-method move_object - (of-object "GESSimpleTimelineLayer") - (c-name "ges_simple_timeline_layer_move_object") - (return-type "gboolean") - (parameters - '("GESTimelineObject*" "object") - '("gint" "newposition") - ) -) - -(define-method is_valid - (of-object "GESSimpleTimelineLayer") - (c-name "ges_simple_timeline_layer_is_valid") - (return-type "gboolean") -) - -(define-method nth - (of-object "GESSimpleTimelineLayer") - (c-name "ges_simple_timeline_layer_nth") - (return-type "GESTimelineObject*") - (parameters - '("gint" "position") - ) -) - -(define-method index - (of-object "GESSimpleTimelineLayer") - (c-name "ges_simple_timeline_layer_index") - (return-type "gint") - (parameters - '("GESTimelineObject*" "object") - ) -) - - - -;; From ges-timeline-effect.h - -(define-function timeline_effect_get_type - (c-name "ges_timeline_effect_get_type") - (return-type "GType") -) - - - -;; From ges-timeline-file-source.h - -(define-function timeline_filesource_get_type - (c-name "ges_timeline_filesource_get_type") - (return-type "GType") -) - -(define-method set_mute - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_set_mute") - (return-type "none") - (parameters - '("gboolean" "mute") - ) -) - -(define-method set_max_duration - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_set_max_duration") - (return-type "none") - (parameters - '("guint64" "maxduration") - ) -) - -(define-method set_supported_formats - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_set_supported_formats") - (return-type "none") - (parameters - '("GESTrackType" "supportedformats") - ) -) - -(define-method set_is_image - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_set_is_image") - (return-type "none") - (parameters - '("gboolean" "is_image") - ) -) - -(define-method is_muted - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_is_muted") - (return-type "gboolean") -) - -(define-method get_max_duration - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_get_max_duration") - (return-type "guint64") -) - -(define-method is_image - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_is_image") - (return-type "gboolean") -) - -(define-method get_uri - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_get_uri") - (return-type "const-gchar*") -) - -(define-method get_supported_formats - (of-object "GESTimelineFileSource") - (c-name "ges_timeline_filesource_get_supported_formats") - (return-type "GESTrackType") -) - -(define-function timeline_filesource_new - (c-name "ges_timeline_filesource_new") - (is-constructor-of "GESTimelineFileSource") - (return-type "GESTimelineFileSource*") - (parameters - '("gchar*" "uri") - ) -) - - - -;; From ges-timeline.h - -(define-function timeline_get_type - (c-name "ges_timeline_get_type") - (return-type "GType") -) - -(define-function timeline_new - (c-name "ges_timeline_new") - (is-constructor-of "GESTimeline") - (return-type "GESTimeline*") -) - -(define-function timeline_new_from_uri - (c-name "ges_timeline_new_from_uri") - (return-type "GESTimeline*") - (parameters - '("const-gchar*" "uri") - ) -) - -(define-method load_from_uri - (of-object "GESTimeline") - (c-name "ges_timeline_load_from_uri") - (return-type "gboolean") - (parameters - '("const-gchar*" "uri") - ) -) - -(define-method save_to_uri - (of-object "GESTimeline") - (c-name "ges_timeline_save_to_uri") - (return-type "gboolean") - (parameters - '("const-gchar*" "uri") - ) -) - -(define-method add_layer - (of-object "GESTimeline") - (c-name "ges_timeline_add_layer") - (return-type "gboolean") - (parameters - '("GESTimelineLayer*" "layer") - ) -) - -(define-method remove_layer - (of-object "GESTimeline") - (c-name "ges_timeline_remove_layer") - (return-type "gboolean") - (parameters - '("GESTimelineLayer*" "layer") - ) -) - -(define-method get_layers - (of-object "GESTimeline") - (c-name "ges_timeline_get_layers") - (return-type "GList*") -) - -(define-method add_track - (of-object "GESTimeline") - (c-name "ges_timeline_add_track") - (return-type "gboolean") - (parameters - '("GESTrack*" "track") - ) -) - -(define-method remove_track - (of-object "GESTimeline") - (c-name "ges_timeline_remove_track") - (return-type "gboolean") - (parameters - '("GESTrack*" "track") - ) -) - -(define-method get_track_for_pad - (of-object "GESTimeline") - (c-name "ges_timeline_get_track_for_pad") - (return-type "GESTrack*") - (parameters - '("GstPad*" "pad") - ) -) - -(define-method get_tracks - (of-object "GESTimeline") - (c-name "ges_timeline_get_tracks") - (return-type "GList*") -) - - - -;; From ges-timeline-layer.h - -(define-function timeline_layer_get_type - (c-name "ges_timeline_layer_get_type") - (return-type "GType") -) - -(define-function timeline_layer_new - (c-name "ges_timeline_layer_new") - (is-constructor-of "GESTimelineLayer") - (return-type "GESTimelineLayer*") -) - -(define-method set_timeline - (of-object "GESTimelineLayer") - (c-name "ges_timeline_layer_set_timeline") - (return-type "none") - (parameters - '("GESTimeline*" "timeline") - ) -) - -(define-method add_object - (of-object "GESTimelineLayer") - (c-name "ges_timeline_layer_add_object") - (return-type "gboolean") - (parameters - '("GESTimelineObject*" "object") - ) -) - -(define-method remove_object - (of-object "GESTimelineLayer") - (c-name "ges_timeline_layer_remove_object") - (return-type "gboolean") - (parameters - '("GESTimelineObject*" "object") - ) -) - -(define-method set_priority - (of-object "GESTimelineLayer") - (c-name "ges_timeline_layer_set_priority") - (return-type "none") - (parameters - '("guint" "priority") - ) -) - -(define-method get_priority - (of-object "GESTimelineLayer") - (c-name "ges_timeline_layer_get_priority") - (return-type "guint") -) - -(define-method get_objects - (of-object "GESTimelineLayer") - (c-name "ges_timeline_layer_get_objects") - (return-type "GList*") -) - - - -;; From ges-timeline-object.h - -(define-function timeline_object_get_type - (c-name "ges_timeline_object_get_type") - (return-type "GType") -) - -(define-method set_start - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_set_start") - (return-type "none") - (parameters - '("guint64" "start") - ) -) - -(define-method set_inpoint - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_set_inpoint") - (return-type "none") - (parameters - '("guint64" "inpoint") - ) -) - -(define-method set_duration - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_set_duration") - (return-type "none") - (parameters - '("guint64" "duration") - ) -) - -(define-method set_priority - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_set_priority") - (return-type "none") - (parameters - '("guint" "priority") - ) -) - -(define-method set_layer - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_set_layer") - (return-type "none") - (parameters - '("GESTimelineLayer*" "layer") - ) -) - -(define-method create_track_object - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_create_track_object") - (return-type "GESTrackObject*") - (parameters - '("GESTrack*" "track") - ) -) - -(define-method create_track_objects - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_create_track_objects") - (return-type "gboolean") - (parameters - '("GESTrack*" "track") - ) -) - -(define-method release_track_object - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_release_track_object") - (return-type "gboolean") - (parameters - '("GESTrackObject*" "trackobject") - ) -) - -(define-method fill_track_object - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_fill_track_object") - (return-type "gboolean") - (parameters - '("GESTrackObject*" "trackobj") - '("GstElement*" "gnlobj") - ) -) - -(define-method find_track_object - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_find_track_object") - (return-type "GESTrackObject*") - (parameters - '("GESTrack*" "track") - '("GType" "type") - ) -) - -(define-method get_track_objects - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_get_track_objects") - (return-type "GList*") -) - -(define-method add_track_object - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_add_track_object") - (return-type "gboolean") - (parameters - '("GESTrackObject*" "trobj") - ) -) - -(define-method get_layer - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_get_layer") - (return-type "GESTimelineLayer*") -) - -(define-method get_top_effects - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_get_top_effects") - (return-type "GList*") -) - -(define-method get_top_effect_position - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_get_top_effect_position") - (return-type "gint") - (parameters - '("GESTrackEffect*" "effect") - ) -) - -(define-method set_top_effect_priority - (of-object "GESTimelineObject") - (c-name "ges_timeline_object_set_top_effect_priority") - (return-type "gboolean") - (parameters - '("GESTrackEffect*" "effect") - '("guint" "newpriority") - ) -) - - - -;; From ges-timeline-operation.h - -(define-function timeline_operation_get_type - (c-name "ges_timeline_operation_get_type") - (return-type "GType") -) - - - -;; From ges-timeline-overlay.h - -(define-function timeline_overlay_get_type - (c-name "ges_timeline_overlay_get_type") - (return-type "GType") -) - - - -;; From ges-timeline-parse-launch-effect.h - -(define-function timeline_parse_launch_effect_get_type - (c-name "ges_timeline_parse_launch_effect_get_type") - (return-type "GType") -) - -(define-function timeline_parse_launch_effect_new - (c-name "ges_timeline_parse_launch_effect_new") - (is-constructor-of "GESTimelineParseLaunchEffect") - (return-type "GESTimelineParseLaunchEffect*") - (parameters - '("const-gchar*" "video_bin_description") - '("const-gchar*" "audio_bin_description") - ) -) - - - -;; From ges-timeline-pipeline.h - -(define-function timeline_pipeline_get_type - (c-name "ges_timeline_pipeline_get_type") - (return-type "GType") -) - -(define-function timeline_pipeline_new - (c-name "ges_timeline_pipeline_new") - (is-constructor-of "GESTimelinePipeline") - (return-type "GESTimelinePipeline*") -) - -(define-method add_timeline - (of-object "GESTimelinePipeline") - (c-name "ges_timeline_pipeline_add_timeline") - (return-type "gboolean") - (parameters - '("GESTimeline*" "timeline") - ) -) - -(define-method set_render_settings - (of-object "GESTimelinePipeline") - (c-name "ges_timeline_pipeline_set_render_settings") - (return-type "gboolean") - (parameters - '("gchar*" "output_uri") - '("GstEncodingProfile*" "profile") - ) -) - -(define-method set_mode - (of-object "GESTimelinePipeline") - (c-name "ges_timeline_pipeline_set_mode") - (return-type "gboolean") - (parameters - '("GESPipelineFlags" "mode") - ) -) - -(define-method get_thumbnail_buffer - (of-object "GESTimelinePipeline") - (c-name "ges_timeline_pipeline_get_thumbnail_buffer") - (return-type "GstBuffer*") - (parameters - '("GstCaps*" "caps") - ) -) - -(define-method get_thumbnail_rgb24 - (of-object "GESTimelinePipeline") - (c-name "ges_timeline_pipeline_get_thumbnail_rgb24") - (return-type "GstBuffer*") - (parameters - '("gint" "width") - '("gint" "height") - ) -) - -(define-method save_thumbnail - (of-object "GESTimelinePipeline") - (c-name "ges_timeline_pipeline_save_thumbnail") - (return-type "gboolean") - (parameters - '("int" "width") - '("int" "height") - '("const-gchar*" "format") - '("const-gchar*" "location") - ) -) - - - -;; From ges-timeline-source.h - -(define-function timeline_source_get_type - (c-name "ges_timeline_source_get_type") - (return-type "GType") -) - - - -;; From ges-timeline-standard-transition.h - -(define-function timeline_standard_transition_get_type - (c-name "ges_timeline_standard_transition_get_type") - (return-type "GType") -) - -(define-function timeline_standard_transition_new - (c-name "ges_timeline_standard_transition_new") - (is-constructor-of "GESTimelineStandardTransition") - (return-type "GESTimelineStandardTransition*") - (parameters - '("GESVideoStandardTransitionType" "vtype") - ) -) - -(define-function timeline_standard_transition_new_for_nick - (c-name "ges_timeline_standard_transition_new_for_nick") - (return-type "GESTimelineStandardTransition*") - (parameters - '("char*" "nick") - ) -) - - - -;; From ges-timeline-test-source.h - -(define-function timeline_test_source_get_type - (c-name "ges_timeline_test_source_get_type") - (return-type "GType") -) - -(define-method set_mute - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_set_mute") - (return-type "none") - (parameters - '("gboolean" "mute") - ) -) - -(define-method set_vpattern - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_set_vpattern") - (return-type "none") - (parameters - '("GESVideoTestPattern" "vpattern") - ) -) - -(define-method set_frequency - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_set_frequency") - (return-type "none") - (parameters - '("gdouble" "freq") - ) -) - -(define-method set_volume - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_set_volume") - (return-type "none") - (parameters - '("gdouble" "volume") - ) -) - -(define-method get_vpattern - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_get_vpattern") - (return-type "GESVideoTestPattern") -) - -(define-method is_muted - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_is_muted") - (return-type "gboolean") -) - -(define-method get_frequency - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_get_frequency") - (return-type "gdouble") -) - -(define-method get_volume - (of-object "GESTimelineTestSource") - (c-name "ges_timeline_test_source_get_volume") - (return-type "gdouble") -) - -(define-function timeline_test_source_new - (c-name "ges_timeline_test_source_new") - (is-constructor-of "GESTimelineTestSource") - (return-type "GESTimelineTestSource*") -) - -(define-function timeline_test_source_new_for_nick - (c-name "ges_timeline_test_source_new_for_nick") - (return-type "GESTimelineTestSource*") - (parameters - '("gchar*" "nick") - ) -) - - - -;; From ges-timeline-text-overlay.h - -(define-function timeline_text_overlay_get_type - (c-name "ges_timeline_text_overlay_get_type") - (return-type "GType") -) - -(define-method set_text - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_set_text") - (return-type "none") - (parameters - '("const-gchar*" "text") - ) -) - -(define-method set_font_desc - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_set_font_desc") - (return-type "none") - (parameters - '("const-gchar*" "font_desc") - ) -) - -(define-method set_valign - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_set_valign") - (return-type "none") - (parameters - '("GESTextVAlign" "valign") - ) -) - -(define-method set_halign - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_set_halign") - (return-type "none") - (parameters - '("GESTextHAlign" "halign") - ) -) - -(define-method get_text - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_get_text") - (return-type "const-gchar*") -) - -(define-method get_font_desc - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_get_font_desc") - (return-type "const-gchar*") -) - -(define-method get_valignment - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_get_valignment") - (return-type "GESTextVAlign") -) - -(define-method get_halignment - (of-object "GESTimelineTextOverlay") - (c-name "ges_timeline_text_overlay_get_halignment") - (return-type "GESTextHAlign") -) - -(define-function timeline_text_overlay_new - (c-name "ges_timeline_text_overlay_new") - (is-constructor-of "GESTimelineTextOverlay") - (return-type "GESTimelineTextOverlay*") -) - - - -;; From ges-timeline-title-source.h - -(define-function timeline_title_source_get_type - (c-name "ges_timeline_title_source_get_type") - (return-type "GType") -) - -(define-method set_mute - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_set_mute") - (return-type "none") - (parameters - '("gboolean" "mute") - ) -) - -(define-method set_text - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_set_text") - (return-type "none") - (parameters - '("const-gchar*" "text") - ) -) - -(define-method set_font_desc - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_set_font_desc") - (return-type "none") - (parameters - '("const-gchar*" "font_desc") - ) -) - -(define-method set_valignment - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_set_valignment") - (return-type "none") - (parameters - '("GESTextVAlign" "valign") - ) -) - -(define-method set_halignment - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_set_halignment") - (return-type "none") - (parameters - '("GESTextHAlign" "halign") - ) -) - -(define-method get_font_desc - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_get_font_desc") - (return-type "const-gchar*") -) - -(define-method get_valignment - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_get_valignment") - (return-type "GESTextVAlign") -) - -(define-method get_halignment - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_get_halignment") - (return-type "GESTextHAlign") -) - -(define-method is_muted - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_is_muted") - (return-type "gboolean") -) - -(define-method get_text - (of-object "GESTimelineTitleSource") - (c-name "ges_timeline_title_source_get_text") - (return-type "const-gchar*") -) - -(define-function timeline_title_source_new - (c-name "ges_timeline_title_source_new") - (is-constructor-of "GESTimelineTitleSource") - (return-type "GESTimelineTitleSource*") -) - - - -;; From ges-timeline-transition.h - -(define-function timeline_transition_get_type - (c-name "ges_timeline_transition_get_type") - (return-type "GType") -) - - - -;; From ges-track-audio-test-source.h - -(define-function track_audio_test_source_get_type - (c-name "ges_track_audio_test_source_get_type") - (return-type "GType") -) - -(define-method set_freq - (of-object "GESTrackAudioTestSource") - (c-name "ges_track_audio_test_source_set_freq") - (return-type "none") - (parameters - '("gdouble" "freq") - ) -) - -(define-method set_volume - (of-object "GESTrackAudioTestSource") - (c-name "ges_track_audio_test_source_set_volume") - (return-type "none") - (parameters - '("gdouble" "volume") - ) -) - -(define-method get_freq - (of-object "GESTrackAudioTestSource") - (c-name "ges_track_audio_test_source_get_freq") - (return-type "double") -) - -(define-method get_volume - (of-object "GESTrackAudioTestSource") - (c-name "ges_track_audio_test_source_get_volume") - (return-type "double") -) - -(define-function track_audio_test_source_new - (c-name "ges_track_audio_test_source_new") - (is-constructor-of "GESTrackAudioTestSource") - (return-type "GESTrackAudioTestSource*") -) - - - -;; From ges-track-audio-transition.h - -(define-function track_audio_transition_get_type - (c-name "ges_track_audio_transition_get_type") - (return-type "GType") -) - -(define-function track_audio_transition_new - (c-name "ges_track_audio_transition_new") - (is-constructor-of "GESTrackAudioTransition") - (return-type "GESTrackAudioTransition*") -) - - - -;; From ges-track-effect.h - -(define-function track_effect_get_type - (c-name "ges_track_effect_get_type") - (return-type "GType") -) - - - -;; From ges-track-filesource.h - -(define-function track_filesource_get_type - (c-name "ges_track_filesource_get_type") - (return-type "GType") -) - -(define-function track_filesource_new - (c-name "ges_track_filesource_new") - (is-constructor-of "GESTrackFilesource") - (return-type "GESTrackFileSource*") - (parameters - '("gchar*" "uri") - ) -) - - - -;; From ges-track.h - -(define-function track_get_type - (c-name "ges_track_get_type") - (return-type "GType") -) - -(define-function track_new - (c-name "ges_track_new") - (is-constructor-of "GESTrack") - (return-type "GESTrack*") - (parameters - '("GESTrackType" "type") - '("GstCaps*" "caps") - ) -) - -(define-method set_timeline - (of-object "GESTrack") - (c-name "ges_track_set_timeline") - (return-type "none") - (parameters - '("GESTimeline*" "timeline") - ) -) - -(define-method set_caps - (of-object "GESTrack") - (c-name "ges_track_set_caps") - (return-type "none") - (parameters - '("const-GstCaps*" "caps") - ) -) - -(define-method get_caps - (of-object "GESTrack") - (c-name "ges_track_get_caps") - (return-type "const-GstCaps*") -) - -(define-method get_timeline - (of-object "GESTrack") - (c-name "ges_track_get_timeline") - (return-type "const-GESTimeline*") -) - -(define-method add_object - (of-object "GESTrack") - (c-name "ges_track_add_object") - (return-type "gboolean") - (parameters - '("GESTrackObject*" "object") - ) -) - -(define-method remove_object - (of-object "GESTrack") - (c-name "ges_track_remove_object") - (return-type "gboolean") - (parameters - '("GESTrackObject*" "object") - ) -) - -(define-function track_video_raw_new - (c-name "ges_track_video_raw_new") - (return-type "GESTrack*") -) - -(define-function track_audio_raw_new - (c-name "ges_track_audio_raw_new") - (return-type "GESTrack*") -) - - - -;; From ges-track-image-source.h - -(define-function track_image_source_get_type - (c-name "ges_track_image_source_get_type") - (return-type "GType") -) - -(define-function track_image_source_new - (c-name "ges_track_image_source_new") - (is-constructor-of "GESTrackImageSource") - (return-type "GESTrackImageSource*") - (parameters - '("gchar*" "uri") - ) -) - - - -;; From ges-track-object.h - -(define-function track_object_get_type - (c-name "ges_track_object_get_type") - (return-type "GType") -) - -(define-method set_track - (of-object "GESTrackObject") - (c-name "ges_track_object_set_track") - (return-type "gboolean") - (parameters - '("GESTrack*" "track") - ) -) - -(define-method get_track - (of-object "GESTrackObject") - (c-name "ges_track_object_get_track") - (return-type "GESTrack*") -) - -(define-method set_timeline_object - (of-object "GESTrackObject") - (c-name "ges_track_object_set_timeline_object") - (return-type "none") - (parameters - '("GESTimelineObject*" "tlobject") - ) -) - -(define-method get_timeline_object - (of-object "GESTrackObject") - (c-name "ges_track_object_get_timeline_object") - (return-type "GESTimelineObject*") -) - -(define-method get_gnlobject - (of-object "GESTrackObject") - (c-name "ges_track_object_get_gnlobject") - (return-type "GstElement*") -) - -(define-method get_element - (of-object "GESTrackObject") - (c-name "ges_track_object_get_element") - (return-type "GstElement*") -) - -(define-method set_locked - (of-object "GESTrackObject") - (c-name "ges_track_object_set_locked") - (return-type "none") - (parameters - '("gboolean" "locked") - ) -) - -(define-method is_locked - (of-object "GESTrackObject") - (c-name "ges_track_object_is_locked") - (return-type "gboolean") -) - -(define-method set_start - (of-object "GESTrackObject") - (c-name "ges_track_object_set_start") - (return-type "none") - (parameters - '("guint64" "start") - ) -) - -(define-method set_inpoint - (of-object "GESTrackObject") - (c-name "ges_track_object_set_inpoint") - (return-type "none") - (parameters - '("guint64" "inpoint") - ) -) - -(define-method set_duration - (of-object "GESTrackObject") - (c-name "ges_track_object_set_duration") - (return-type "none") - (parameters - '("guint64" "duration") - ) -) - -(define-method set_priority - (of-object "GESTrackObject") - (c-name "ges_track_object_set_priority") - (return-type "none") - (parameters - '("guint32" "priority") - ) -) - -(define-method set_active - (of-object "GESTrackObject") - (c-name "ges_track_object_set_active") - (return-type "gboolean") - (parameters - '("gboolean" "active") - ) -) - -(define-method get_start - (of-object "GESTrackObject") - (c-name "ges_track_object_get_start") - (return-type "guint64") -) - -(define-method get_inpoint - (of-object "GESTrackObject") - (c-name "ges_track_object_get_inpoint") - (return-type "guint64") -) - -(define-method get_duration - (of-object "GESTrackObject") - (c-name "ges_track_object_get_duration") - (return-type "guint64") -) - -(define-method get_priority - (of-object "GESTrackObject") - (c-name "ges_track_object_get_priority") - (return-type "guint32") -) - -(define-method is_active - (of-object "GESTrackObject") - (c-name "ges_track_object_is_active") - (return-type "gboolean") -) - -(define-method list_children_properties - (of-object "GESTrackObject") - (c-name "ges_track_object_list_children_properties") - (return-type "GParamSpec**") - (parameters - '("guint*" "n_properties") - ) -) - -(define-method lookup_child - (of-object "GESTrackObject") - (c-name "ges_track_object_lookup_child") - (return-type "gboolean") - (parameters - '("const-gchar*" "prop_name") - '("GstElement**" "element") - '("GParamSpec**" "pspec") - ) -) - -(define-method get_child_property_by_pspec - (of-object "GESTrackObject") - (c-name "ges_track_object_get_child_property_by_pspec") - (return-type "none") - (parameters - '("GParamSpec*" "pspec") - '("GValue*" "value") - ) -) - -(define-method get_child_property_valist - (of-object "GESTrackObject") - (c-name "ges_track_object_get_child_property_valist") - (return-type "none") - (parameters - '("const-gchar*" "first_property_name") - '("va_list" "var_args") - ) -) - -(define-method get_child_property - (of-object "GESTrackObject") - (c-name "ges_track_object_get_child_property") - (return-type "none") - (parameters - '("const-gchar*" "first_property_name") - ) - (varargs #t) -) - -(define-method set_child_property_valist - (of-object "GESTrackObject") - (c-name "ges_track_object_set_child_property_valist") - (return-type "none") - (parameters - '("const-gchar*" "first_property_name") - '("va_list" "var_args") - ) -) - -(define-method set_child_property_by_pspec - (of-object "GESTrackObject") - (c-name "ges_track_object_set_child_property_by_pspec") - (return-type "none") - (parameters - '("GParamSpec*" "pspec") - '("GValue*" "value") - ) -) - -(define-method set_child_property - (of-object "GESTrackObject") - (c-name "ges_track_object_set_child_property") - (return-type "none") - (parameters - '("const-gchar*" "first_property_name") - ) - (varargs #t) -) - - - -;; From ges-track-operation.h - -(define-function track_operation_get_type - (c-name "ges_track_operation_get_type") - (return-type "GType") -) - - - -;; From ges-track-parse-launch-effect.h - -(define-function track_parse_launch_effect_get_type - (c-name "ges_track_parse_launch_effect_get_type") - (return-type "GType") -) - -(define-function track_parse_launch_effect_new - (c-name "ges_track_parse_launch_effect_new") - (is-constructor-of "GESTrackParseLaunchEffect") - (return-type "GESTrackParseLaunchEffect*") - (parameters - '("const-gchar*" "bin_description") - ) -) - - - -;; From ges-track-source.h - -(define-function track_source_get_type - (c-name "ges_track_source_get_type") - (return-type "GType") -) - - - -;; From ges-track-text-overlay.h - -(define-function track_text_overlay_get_type - (c-name "ges_track_text_overlay_get_type") - (return-type "GType") -) - -(define-method set_text - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_set_text") - (return-type "none") - (parameters - '("const-gchar*" "text") - ) -) - -(define-method set_font_desc - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_set_font_desc") - (return-type "none") - (parameters - '("const-gchar*" "font_desc") - ) -) - -(define-method set_halignment - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_set_halignment") - (return-type "none") - (parameters - '("GESTextHAlign" "halign") - ) -) - -(define-method set_valignment - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_set_valignment") - (return-type "none") - (parameters - '("GESTextVAlign" "valign") - ) -) - -(define-method get_text - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_get_text") - (return-type "const-gchar*") -) - -(define-method get_font_desc - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_get_font_desc") - (return-type "const-char*") -) - -(define-method get_halignment - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_get_halignment") - (return-type "GESTextHAlign") -) - -(define-method get_valignment - (of-object "GESTrackTextOverlay") - (c-name "ges_track_text_overlay_get_valignment") - (return-type "GESTextVAlign") -) - -(define-function track_text_overlay_new - (c-name "ges_track_text_overlay_new") - (is-constructor-of "GESTrackTextOverlay") - (return-type "GESTrackTextOverlay*") -) - - - -;; From ges-track-title-source.h - -(define-function track_title_source_get_type - (c-name "ges_track_title_source_get_type") - (return-type "GType") -) - -(define-method set_text - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_set_text") - (return-type "none") - (parameters - '("const-gchar*" "text") - ) -) - -(define-method set_font_desc - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_set_font_desc") - (return-type "none") - (parameters - '("const-gchar*" "font_desc") - ) -) - -(define-method set_halignment - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_set_halignment") - (return-type "none") - (parameters - '("GESTextHAlign" "halign") - ) -) - -(define-method set_valignment - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_set_valignment") - (return-type "none") - (parameters - '("GESTextVAlign" "valign") - ) -) - -(define-method get_text - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_get_text") - (return-type "const-gchar*") -) - -(define-method get_font_desc - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_get_font_desc") - (return-type "const-gchar*") -) - -(define-method get_halignment - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_get_halignment") - (return-type "GESTextHAlign") -) - -(define-method get_valignment - (of-object "GESTrackTitleSource") - (c-name "ges_track_title_source_get_valignment") - (return-type "GESTextVAlign") -) - -(define-function track_title_source_new - (c-name "ges_track_title_source_new") - (is-constructor-of "GESTrackTitleSource") - (return-type "GESTrackTitleSource*") -) - - - -;; From ges-track-transition.h - -(define-function track_transition_get_type - (c-name "ges_track_transition_get_type") - (return-type "GType") -) - - - -;; From ges-track-video-test-source.h - -(define-function track_video_test_source_get_type - (c-name "ges_track_video_test_source_get_type") - (return-type "GType") -) - -(define-function track_video_test_source_new - (c-name "ges_track_video_test_source_new") - (is-constructor-of "GESTrackVideoTestSource") - (return-type "GESTrackVideoTestSource*") -) - -(define-method set_pattern - (of-object "GESTrackVideoTestSource") - (c-name "ges_track_video_test_source_set_pattern") - (return-type "none") - (parameters - '("GESVideoTestPattern" "pattern") - ) -) - -(define-method get_pattern - (of-object "GESTrackVideoTestSource") - (c-name "ges_track_video_test_source_get_pattern") - (return-type "GESVideoTestPattern") -) - - - -;; From ges-track-video-transition.h - -(define-function track_video_transition_get_type - (c-name "ges_track_video_transition_get_type") - (return-type "GType") -) - -(define-method set_transition_type - (of-object "GESTrackVideoTransition") - (c-name "ges_track_video_transition_set_transition_type") - (return-type "gboolean") - (parameters - '("GESVideoStandardTransitionType" "type") - ) -) - -(define-method get_transition_type - (of-object "GESTrackVideoTransition") - (c-name "ges_track_video_transition_get_transition_type") - (return-type "GESVideoStandardTransitionType") -) - -(define-function track_video_transition_new - (c-name "ges_track_video_transition_new") - (is-constructor-of "GESTrackVideoTransition") - (return-type "GESTrackVideoTransition*") -) - - - -;; From ges-types.h - - - -;; From ges-utils.h - -(define-function timeline_new_audio_video - (c-name "ges_timeline_new_audio_video") - (return-type "GESTimeline*") -) - - - -;; From config.h - - diff --git a/bindings/python/ges.override b/bindings/python/ges.override deleted file mode 100644 index 82eada7976..0000000000 --- a/bindings/python/ges.override +++ /dev/null @@ -1,401 +0,0 @@ -/* -*- Mode: C; c-basic-offset: 4 -*- */ -%% -headers -#define NO_IMPORT_PYGOBJECT -#include -#include - -#include -#include -#include - -#include -#include - - -#ifdef HAVE_CONFIG_H -# include -#endif - -/* Boonky define that allows for backwards compatibility with Python 2.4 */ -#if PY_VERSION_HEX < 0x02050000 -#define Py_ssize_t int -#endif - -void pyges_register_classes(PyObject *d); -void pyges_add_constants(PyObject *module, const gchar *strip_prefix); - -%% -import gobject.GObject as PyGObject_Type -import gobject.MainContext as PyGMainContext_Type -import gobject.GObject as PyGInitiallyUnowned_Type -import gst.Bin as PyGstBin_Type -import gst.Pipeline as PyGstPipeline_Type -import gst.Element as PyGstElement_Type -import gst.Buffer as PyGstBuffer_Type -import gst.Pad as PyGstPad_Type -import gst.pbutils.EncodingProfile as PyGstEncodingProfile_Type - -%% -override ges_track_get_timeline kwargs -static PyObject * -_wrap_ges_track_get_timeline(PyGObject *self) -{ - const GESTimeline *ret; - - pyg_begin_allow_threads; - ret = ges_track_get_timeline(GES_TRACK(self->obj)); - pyg_end_allow_threads; - /* pygobject_new handles NULL checking */ - return pygobject_new((GObject *)ret); -} - -%% -override ges_track_get_caps noargs -static PyObject * -_wrap_ges_track_get_caps(PyGObject *self, void* closure) -{ - const GstCaps *ret; - - ret = ges_track_get_caps(GES_TRACK(self->obj)); - - return pyg_boxed_new (GST_TYPE_CAPS, (GstCaps*) ret, TRUE, TRUE); -} - -%% -override ges_track_set_caps kwargs -static PyObject * -_wrap_ges_track_set_caps(PyGObject *self, PyObject *args, PyObject *kwargs) -{ - static char *kwlist[] = { "caps", NULL }; - PyObject *py_caps; - GstCaps *caps; - - if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GstBuffer.set_caps", kwlist, &py_caps)) - return NULL; - - caps = pyg_boxed_get (py_caps, GstCaps); - if (PyErr_Occurred()) - return NULL; - - pyg_begin_allow_threads; - ges_track_set_caps (GES_TRACK(self->obj), caps); - pyg_end_allow_threads; - Py_INCREF(Py_None); - return Py_None; -} - -%% -new-constructor GES_TYPE_TRACK -%% -override ges_track_new kwargs -static int -_wrap_ges_track_new(PyGObject *self, PyObject *args, PyObject *kwargs) -{ - static char *kwlist[] = { "type", "caps", NULL }; - PyObject *py_type = NULL; - GESTrackType type; - GstCaps *caps; - PyObject *py_caps; - - if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:GES.Track.__init__", kwlist, &py_type, &py_caps)) - return -1; - if (pyg_flags_get_value(GES_TYPE_TRACK_TYPE, py_type, (gpointer)&type)) - return -1; - caps = pyg_boxed_get (py_caps, GstCaps); - self->obj = (GObject *)ges_track_new(type, caps); - - if (!self->obj) { - PyErr_SetString(PyExc_RuntimeError, "could not create GESTrack object"); - return -1; - } - pygobject_register_wrapper((PyObject *)self); - return 0; -} - -%% -override ges_track_object_lookup_child kwargs -static PyObject * -_wrap_ges_track_object_lookup_child(PyGObject *self, PyObject *args, PyObject *kwargs) -{ - static char *kwlist[] = {"name", NULL}; - char *name = NULL; - GParamSpec *pspec; - GstElement *element; - gboolean ret; - - if (!PyArg_ParseTupleAndKeywords(args, kwargs, - "z:GES.TrackObject.lookup_child", kwlist, &name)) - return FALSE; - - pyg_begin_allow_threads; - ret = ges_track_object_lookup_child (GES_TRACK_OBJECT (self->obj), name, &element, &pspec); - pyg_end_allow_threads; - - if (!ret) - return PyBool_FromLong(ret); - return pygobject_new((GObject *)element); -} - -%% -override ges_timeline_parse_launch_effect_new kwargs -static int -_wrap_ges_timeline_parse_launch_effect_new(PyGObject *self, PyObject *args, PyObject *kwargs) -{ - static char *kwlist[] = { "video_bin_description", "audio_bin_description", NULL }; - char *video_bin_description, *audio_bin_description = NULL; - - if (!PyArg_ParseTupleAndKeywords(args, kwargs,"zz:GES.TimelineParseLaunchEffect.__init__", kwlist, &video_bin_description, &audio_bin_description)) - return -1; - self->obj = (GObject *)ges_timeline_parse_launch_effect_new(video_bin_description, audio_bin_description); - - if (!self->obj) { - PyErr_SetString(PyExc_RuntimeError, "could not create GESTimelineParseLaunchEffect object"); - return -1; - } - pygobject_register_wrapper((PyObject *)self); - return 0; -} - -/* I did not override ges_formatter_get_data and set_data for these functions are deprecated */ - -%% -override ges_timeline_object_get_top_effects noargs -static PyObject * -_wrap_ges_timeline_object_get_top_effects(PyGObject *self) -{ - const GList *l, *list; - PyObject *py_list; - - g_return_val_if_fail (GES_IS_TIMELINE_OBJECT (self->obj),PyList_New(0)); - - pyg_begin_allow_threads; - list = ges_timeline_object_get_top_effects(GES_TIMELINE_OBJECT(self->obj)); - pyg_end_allow_threads; - - py_list = PyList_New(0); - for (l = list; l; l = l->next) { - GESTrackEffect *track_effect = (GESTrackEffect*)l->data; - PyObject *py_track_effect = pygobject_new(G_OBJECT(track_effect)); - PyList_Append(py_list, py_track_effect); - Py_DECREF(py_track_effect); - } - - return py_list; -} - -%% -override ges_timeline_get_tracks noargs -static PyObject * -_wrap_ges_timeline_get_tracks(PyGObject *self) -{ - const GList *l, *list; - PyObject *py_list; - - g_return_val_if_fail (GES_IS_TIMELINE (self->obj),PyList_New(0)); - - pyg_begin_allow_threads; - list = ges_timeline_get_tracks(GES_TIMELINE(self->obj)); - pyg_end_allow_threads; - - py_list = PyList_New(0); - for (l = list; l; l = l->next) { - GESTrack *track = (GESTrack*)l->data; - PyObject *py_track = pygobject_new(G_OBJECT(track)); - PyList_Append(py_list, py_track); - Py_DECREF(py_track); - } - - return py_list; -} - -%% -override ges_timeline_get_layers noargs -static PyObject * -_wrap_ges_timeline_get_layers(PyGObject *self) -{ - const GList *l, *list; - PyObject *py_list; - - g_return_val_if_fail (GES_IS_TIMELINE (self->obj), PyList_New(0)); - - pyg_begin_allow_threads; - list = ges_timeline_get_layers(GES_TIMELINE(self->obj)); - pyg_end_allow_threads; - - py_list = PyList_New(0); - for (l = list; l; l = l->next) { - GESTimelineLayer *layer = (GESTimelineLayer*)l->data; - PyObject *py_layer = pygobject_new(G_OBJECT(layer)); - PyList_Append(py_list, py_layer); - Py_DECREF(py_layer); - } - - return py_list; -} - -%% -override ges_timeline_layer_get_objects noargs -static PyObject * -_wrap_ges_timeline_layer_get_objects(PyGObject *self) -{ - const GList *l, *list; - PyObject *py_list; - - g_return_val_if_fail (GES_IS_TIMELINE_LAYER (self->obj), PyList_New(0)); - - pyg_begin_allow_threads; - list = ges_timeline_layer_get_objects(GES_TIMELINE_LAYER(self->obj)); - pyg_end_allow_threads; - - py_list = PyList_New(0); - for (l = list; l; l = l->next) { - GESTimelineObject *object = (GESTimelineObject*)l->data; - PyObject *py_object = pygobject_new(G_OBJECT(object)); - PyList_Append(py_list, py_object); - Py_DECREF(py_object); - } - - return py_list; -} - -%% -override ges_timeline_object_get_track_objects noargs -static PyObject * -_wrap_ges_timeline_object_get_track_objects(PyGObject *self) -{ - const GList *l, *list; - PyObject *py_list; - - g_return_val_if_fail (GES_IS_TIMELINE_OBJECT (self->obj), PyList_New(0)); - - pyg_begin_allow_threads; - list = ges_timeline_object_get_track_objects(GES_TIMELINE_OBJECT(self->obj)); - pyg_end_allow_threads; - - py_list = PyList_New(0); - for (l = list; l; l = l->next) { - GESTrackObject *object = (GESTrackObject*)l->data; - PyObject *py_object = pygobject_new(G_OBJECT(object)); - PyList_Append(py_list, py_object); - Py_DECREF(py_object); - } - - return py_list; -} - -%% -override ges_track_object_get_child_property kwargs -static PyObject * -_wrap_ges_track_object_get_child_property (PyGObject *self, PyObject *args, PyObject *kwargs) -{ - gchar *property_name; - GESTrackObject *obj = GES_TRACK_OBJECT (self->obj); - - GParamSpec *pspec = NULL; - GValue value = { 0, } ; - PyObject *ret; - - if (!PyArg_ParseTuple(args, "s:GESTrackObject.get_child_property", - &property_name)) { - return NULL; - } - - ges_track_object_lookup_child(obj, property_name, NULL, &pspec); - if (!pspec) { - gchar buf[512]; - g_snprintf(buf, sizeof(buf), - "container does not support property `%s'", - property_name); - - PyErr_SetString(PyExc_TypeError, buf); - return NULL; - } - - g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec)); - - ges_track_object_get_child_property_by_pspec(obj, - pspec, - &value); - - ret = pyg_value_as_pyobject(&value, TRUE); - g_value_unset(&value); - - return ret; -} - -%% -override ges_track_object_set_child_property kwargs -static PyObject * -_wrap_ges_track_object_set_child_property (PyGObject *self, PyObject *args, PyObject *kwargs) -{ - gchar *property_name; - GESTrackObject *obj = GES_TRACK_OBJECT (self->obj); - - GParamSpec *pspec = NULL; - PyGObject *pyvalue; - GValue value = { 0, } ; - - if (!PyArg_ParseTuple(args, "sO:GESTrackObject.set_child_property", - &property_name, &pyvalue)) { - return NULL; - } - - ges_track_object_lookup_child(obj, property_name, NULL, &pspec); - if (!pspec) { - gchar buf[512]; - g_snprintf(buf, sizeof(buf), - "container does not support property `%s'", - property_name); - - PyErr_SetString(PyExc_TypeError, buf); - return NULL; - } - - g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(pspec)); - pyg_value_from_pyobject(&value, (PyObject*)pyvalue); - - ges_track_object_set_child_property_by_pspec(obj, - pspec, - &value); - - g_value_unset(&value); - - Py_INCREF(Py_None); - return Py_None; -} - -%% -override ges_track_object_list_children_properties noargs -static PyObject * -_wrap_ges_track_object_list_children_properties (PyGObject *self) -{ - GParamSpec **specs; - PyObject *list; - guint nprops; - guint i; - - specs = ges_track_object_list_children_properties(GES_TRACK_OBJECT (self->obj), &nprops); - list = PyTuple_New(nprops); - if (list == NULL) { - g_free(specs); - return NULL; - } - - for (i = 0; i < nprops; i++) { - PyTuple_SetItem(list, i, pyg_param_spec_new(specs[i])); - } - - g_free(specs); - - return list; -} - -%% -ignore-glob - - *_get_type - ges_formatter_set_data - ges_formatter_set_data - *_valist - *_by_pspec diff --git a/bindings/python/gesmodule.c b/bindings/python/gesmodule.c deleted file mode 100644 index fee7b7d496..0000000000 --- a/bindings/python/gesmodule.c +++ /dev/null @@ -1,37 +0,0 @@ -/* -*- Mode: C; c-basic-offset: 4 -*- */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif -#include -#include -#include -#include - -/* include any extra headers needed here */ - -void pyges_register_classes (PyObject * d); -extern PyMethodDef pyges_functions[]; -DL_EXPORT (void) -initges (void); - -DL_EXPORT (void) -initges (void) -{ - PyObject *m, *d; - - /* perform any initialisation required by the library here */ - - m = Py_InitModule ("ges", pyges_functions); - d = PyModule_GetDict (m); - - init_pygobject (); - pygst_init (); - - pygst_init (); - pyges_register_classes (d); - - /* add anything else to the module dictionary (such as constants) */ - - if (PyErr_Occurred ()) - Py_FatalError ("could not initialise module ges"); -} diff --git a/bindings/python/testsuite/Makefile.am b/bindings/python/testsuite/Makefile.am deleted file mode 100644 index c9df30a02e..0000000000 --- a/bindings/python/testsuite/Makefile.am +++ /dev/null @@ -1,19 +0,0 @@ -EXTRA_DIST = \ - common.py \ - test_timeline_pipeline.py \ - test_timeline.py \ - runtests.py \ - test_global_functions.py \ - test_timeline_test_source.py \ - test_layer.py \ - test_timeline_title_source.py \ - test_simple_layer.py \ - test_track.py \ - test_textoverlay.py \ - test_transition.py \ - test_timeline_file_source.py \ - test_timeline_parse_launch_effect.py - -check: - @PYTHONPATH=$(top_builddir):$(top_builddir)/bindings/python/.libs:`pwd`:$(top_srcdir):$(PYTHONPATH) $(PYTHON) $(srcdir)/runtests.py - @rm -fr *.pyc diff --git a/bindings/python/testsuite/common.py b/bindings/python/testsuite/common.py deleted file mode 100644 index 8fc3e11dbc..0000000000 --- a/bindings/python/testsuite/common.py +++ /dev/null @@ -1,128 +0,0 @@ -# -*- Mode: Python -*- -# vi:si:et:sw=4:sts=4:ts=4 -# -# gst-python - Python bindings for GStreamer -# Copyright (C) 2002 David I. Lehn -# Copyright (C) 2004 Johan Dahlin -# Copyright (C) 2005 Edward Hervey -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -import os -import sys -import gc -import unittest -import gst - -import gobject -try: - gobject.threads_init() -except: - print "WARNING: gobject doesn't have threads_init, no threadsafety" - -def disable_stderr(): - global _stderr - _stderr = file('/tmp/stderr', 'w+') - sys.stderr = os.fdopen(os.dup(2), 'w') - os.close(2) - os.dup(_stderr.fileno()) - -def enable_stderr(): - global _stderr - - os.close(2) - os.dup(sys.stderr.fileno()) - _stderr.seek(0, 0) - data = _stderr.read() - _stderr.close() - os.remove('/tmp/stderr') - return data - -def run_silent(function, *args, **kwargs): - disable_stderr() - - try: - function(*args, **kwargs) - except Exception, exc: - enable_stderr() - raise exc - - output = enable_stderr() - - return output - -class TestCase(unittest.TestCase): - - _types = [gst.Object, gst.MiniObject] - - def gccollect(self): - # run the garbage collector - ret = 0 - gst.debug('garbage collecting') - while True: - c = gc.collect() - ret += c - if c == 0: break - gst.debug('done garbage collecting, %d objects' % ret) - return ret - - def gctrack(self): - # store all gst objects in the gc in a tracking dict - # call before doing any allocation in your test, from setUp - gst.debug('tracking gc GstObjects for types %r' % self._types) - self.gccollect() - self._tracked = {} - for c in self._types: - self._tracked[c] = [o for o in gc.get_objects() if isinstance(o, c)] - - def gcverify(self): - # verify no new gst objects got added to the gc - # call after doing all cleanup in your test, from tearDown - gst.debug('verifying gc GstObjects for types %r' % self._types) - new = [] - for c in self._types: - objs = [o for o in gc.get_objects() if isinstance(o, c)] - new.extend([o for o in objs if o not in self._tracked[c]]) - - self.failIf(new, new) - #self.failIf(new, ["%r:%d" % (type(o), id(o)) for o in new]) - del self._tracked - - def setUp(self): - """ - Override me by chaining up to me at the start of your setUp. - """ - # Using private variables is BAD ! this variable changed name in - # python 2.5 - try: - methodName = self.__testMethodName - except: - methodName = self._testMethodName - gst.debug('%s.%s' % (self.__class__.__name__, methodName)) - self.gctrack() - - def tearDown(self): - """ - Override me by chaining up to me at the end of your tearDown. - """ - # Using private variables is BAD ! this variable changed name in - # python 2.5 - try: - methodName = self.__testMethodName - except: - methodName = self._testMethodName - gst.debug('%s.%s' % (self.__class__.__name__, methodName)) - self.gccollect() - self.gcverify() diff --git a/bindings/python/testsuite/runtests.py b/bindings/python/testsuite/runtests.py deleted file mode 100644 index b6484968e8..0000000000 --- a/bindings/python/testsuite/runtests.py +++ /dev/null @@ -1,37 +0,0 @@ -import glob -import os -import sys -import unittest - -SKIP_FILES = ['common', 'runtests'] - -os.environ['LC_MESSAGES'] = 'C' - -def gettestnames(which): - if not which: - dir = os.path.split(os.path.abspath(__file__))[0] - which = [os.path.basename(p) for p in glob.glob('%s/test_*.py' % dir)] - - names = map(lambda x: x[:-3], which) - for f in SKIP_FILES: - if f in names: - names.remove(f) - return names - -suite = unittest.TestSuite() -loader = unittest.TestLoader() - -for name in gettestnames(sys.argv[1:]): - suite.addTest(loader.loadTestsFromName(name)) - -descriptions = 1 -verbosity = 1 -if os.environ.has_key('VERBOSE'): - descriptions = 2 - verbosity = 2 - -testRunner = unittest.TextTestRunner(descriptions=descriptions, - verbosity=verbosity) -result = testRunner.run(suite) -if result.failures or result.errors: - sys.exit(1) diff --git a/bindings/python/testsuite/test_global_functions.py b/bindings/python/testsuite/test_global_functions.py deleted file mode 100644 index 44d74fcc14..0000000000 --- a/bindings/python/testsuite/test_global_functions.py +++ /dev/null @@ -1,11 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class GlobalFunctions(TestCase): - - def testGlobalFunctions(self): - tl = ges.timeline_new_audio_video() - tr = ges.timeline_standard_transition_new_for_nick("crossfade") diff --git a/bindings/python/testsuite/test_layer.py b/bindings/python/testsuite/test_layer.py deleted file mode 100644 index 991dfe8223..0000000000 --- a/bindings/python/testsuite/test_layer.py +++ /dev/null @@ -1,21 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class Layer(TestCase): - - def testLayer(self): - lyr = ges.TimelineLayer() - tl = ges.Timeline() - src = ges.TimelineTestSource() - - lyr.set_timeline(tl) - - assert (lyr.add_object(src) == True) - self.failIf(len (lyr.get_objects()) != 1) - assert (lyr.remove_object(src) == True) - - lyr.set_priority(1) - self.failIf(lyr.get_priority() != 1) diff --git a/bindings/python/testsuite/test_simple_layer.py b/bindings/python/testsuite/test_simple_layer.py deleted file mode 100644 index 50efa14723..0000000000 --- a/bindings/python/testsuite/test_simple_layer.py +++ /dev/null @@ -1,22 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class SimpleLayer(TestCase): - - def testSimpleLayer(self): - lyr = ges.SimpleTimelineLayer() - tl = ges.Timeline() - src = ges.TimelineTestSource() - src2 = ges.TimelineTestSource() - - lyr.set_timeline(tl) - - assert (lyr.add_object(src, 0) == True) - assert (lyr.add_object(src2, 1) == True) - assert (lyr.nth(0) == src) - assert (lyr.move_object (src, 1) == True) - self.failIf(lyr.index(src) != 1) - assert (lyr.is_valid() == True) diff --git a/bindings/python/testsuite/test_textoverlay.py b/bindings/python/testsuite/test_textoverlay.py deleted file mode 100644 index 4af2532ecf..0000000000 --- a/bindings/python/testsuite/test_textoverlay.py +++ /dev/null @@ -1,60 +0,0 @@ -import gst - -from common import TestCase -import ges -from time import sleep - -class TextOverlay(TestCase): - - def testTextOverlay(self): - - ovrl = ges.TimelineTextOverlay() - lyr = ges.TimelineLayer() - tl = ges.timeline_new_audio_video() - tck = tl.get_tracks()[0] - - ovrl.set_text("Foo") - self.failIf (ovrl.get_text() != "Foo") - ovrl.set_font_desc ("Arial") - self.failIf (ovrl.get_font_desc() != "Arial") - ovrl.set_valign("top") - self.failIf (ovrl.get_valignment().value_name != "top") - ovrl.set_halign("left") - self.failIf (ovrl.get_halignment().value_name != "left") - - #We will test Timeline Object class functions here - - ovrl.set_start(long(100)) - ovrl.set_inpoint(long(50)) - ovrl.set_duration(long(500)) - ovrl.set_priority(2) - ovrl.set_layer(lyr) - tck_obj = ovrl.create_track_object(tck) - self.failIf (ovrl.release_track_object(tck_obj) != True) - self.failIf (ovrl.add_track_object(tck_obj) != True) - self.failIf (len(ovrl.get_track_objects()) != 1) - self.failIf (ovrl.get_layer() != lyr) - ovrl.release_track_object(tck_obj) - - #We test TrackTextOverlay and TrackObject here - tck_obj.set_text("Bar") - self.failIf (tck_obj.get_text() != "Bar") - tck_obj.set_font_desc ("Arial") - self.failIf (tck_obj.get_font_desc() != "Arial") - tck_obj.set_valignment("top") - self.failIf (tck_obj.get_valignment().value_name != "top") - tck_obj.set_halignment("left") - self.failIf (tck_obj.get_halignment().value_name != "left") - - tck_obj.set_locked(False) - self.failIf (tck_obj.is_locked() != False) - tck_obj.set_start(long(100)) - tck_obj.set_inpoint(long(50)) - tck_obj.set_duration(long(500)) - tck_obj.set_priority(2) - self.failIf (tck_obj.get_start() != 100) - self.failIf (tck_obj.get_inpoint() != 50) - self.failIf (tck_obj.get_duration() != 500) - self.failIf (tck_obj.get_priority() != 2) - tck_obj.set_timeline_object(ovrl) - self.failIf(tck_obj.get_timeline_object() != ovrl) diff --git a/bindings/python/testsuite/test_timeline.py b/bindings/python/testsuite/test_timeline.py deleted file mode 100644 index 6be6063b9c..0000000000 --- a/bindings/python/testsuite/test_timeline.py +++ /dev/null @@ -1,22 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class Timeline(TestCase): - - def testTimeline(self): - - tl = ges.timeline_new_audio_video() - lyr = ges.SimpleTimelineLayer() - tck = ges.track_audio_raw_new() - - assert (tl.add_track(tck) == True) - #We should have two tracks from the timeline_new_audio_video() function + 1 - self.failIf(len(tl.get_tracks()) != 3) - assert (tl.remove_track(tck) == True) - - assert (tl.add_layer(lyr) == True) - self.failIf(len(tl.get_layers()) != 1) - assert (tl.remove_layer(lyr) == True) diff --git a/bindings/python/testsuite/test_timeline_file_source.py b/bindings/python/testsuite/test_timeline_file_source.py deleted file mode 100644 index 279c2d6eb0..0000000000 --- a/bindings/python/testsuite/test_timeline_file_source.py +++ /dev/null @@ -1,18 +0,0 @@ -import gst - -from common import TestCase -import ges - -class TimelineFileSource(TestCase): - - def testTimelineFileSource(self): - src = ges.TimelineFileSource("file://blahblahblah") - - src.set_mute(True) - src.set_max_duration(long(100)) - src.set_supported_formats("video") - assert (src.get_supported_formats().value_nicks[0] == "video") - src.set_is_image(True) - assert (src.get_max_duration() == 100) - assert (src.is_image() == True) - assert (src.get_uri() == "file://blahblahblah") diff --git a/bindings/python/testsuite/test_timeline_parse_launch_effect.py b/bindings/python/testsuite/test_timeline_parse_launch_effect.py deleted file mode 100644 index 20d9eb9543..0000000000 --- a/bindings/python/testsuite/test_timeline_parse_launch_effect.py +++ /dev/null @@ -1,24 +0,0 @@ -import gst - -from common import TestCase -import ges -from time import sleep - -class ParseLaunchEffect(TestCase): - - def testParseLaunchEffect(self): - tl = ges.Timeline() - tck = ges.track_video_raw_new() - lyr = ges.TimelineLayer() - efct = ges.TimelineParseLaunchEffect("agingtv", None) - tck_efct = ges.TrackParseLaunchEffect("agingtv") - - tl.add_layer(lyr) - efct.add_track_object(tck_efct) - lyr.add_object(efct) - tck.set_timeline(tl) - tck.add_object(tck_efct) - tck_efct.set_child_property("GstAgingTV::scratch-lines", 17) - self.failIf(tck_efct.get_child_property("GstAgingTV::scratch-lines") != 17) - self.failIf(len(tck_efct.list_children_properties()) != 6) - self.failIf (tck_efct.lookup_child ("scratch-lines") == None) diff --git a/bindings/python/testsuite/test_timeline_pipeline.py b/bindings/python/testsuite/test_timeline_pipeline.py deleted file mode 100644 index b0a0df6a53..0000000000 --- a/bindings/python/testsuite/test_timeline_pipeline.py +++ /dev/null @@ -1,14 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class TimelinePipeline(TestCase): - - def testTimelinePipeline(self): - stgs = gst.pbutils.EncodingAudioProfile(gst.Caps("video/x-dirac"), "test", gst.caps_new_any(), 0) - ppln = ges.TimelinePipeline() - tl = ges.Timeline() - assert (ppln.add_timeline (tl) == True) - assert (ppln.set_mode("TIMELINE_MODE_PREVIEW_AUDIO") == True) diff --git a/bindings/python/testsuite/test_timeline_test_source.py b/bindings/python/testsuite/test_timeline_test_source.py deleted file mode 100644 index f64cb25920..0000000000 --- a/bindings/python/testsuite/test_timeline_test_source.py +++ /dev/null @@ -1,19 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class TimelineTestSource(TestCase): - - def testTimelineTestSource(self): - src = ges.TimelineTestSource() - tck_src = ges.TrackAudioTestSource() - src.set_mute(True) - src.set_vpattern("snow") - src.set_frequency(880) - src.set_volume (1) - assert (src.get_vpattern() != None) - assert (src.is_muted() == True) - assert (src.get_frequency() == 880) - assert (src.get_volume() == 1) diff --git a/bindings/python/testsuite/test_timeline_title_source.py b/bindings/python/testsuite/test_timeline_title_source.py deleted file mode 100644 index 82af574487..0000000000 --- a/bindings/python/testsuite/test_timeline_title_source.py +++ /dev/null @@ -1,23 +0,0 @@ -import gst - -from common import TestCase -import ges - -class TimelineTitleSource(TestCase): - - def testTimelineTitleSource(self): - src = ges.TimelineTitleSource() - lyr = ges.TimelineLayer() - tck = ges.track_video_raw_new() - - src.set_text("Foo") - self.failIf (src.get_text() != "Foo") - src.set_font_desc ("Arial") - self.failIf (src.get_font_desc() != "Arial") - src.set_valignment("top") - assert (src.get_valignment().value_name == "top") - src.set_halignment("left") - assert (src.get_halignment().value_name == "left") - src.set_mute(True) - assert (src.is_muted() == True) - diff --git a/bindings/python/testsuite/test_track.py b/bindings/python/testsuite/test_track.py deleted file mode 100644 index 972a82387f..0000000000 --- a/bindings/python/testsuite/test_track.py +++ /dev/null @@ -1,24 +0,0 @@ -import gst - -from common import TestCase -import ges - -class Track(TestCase): - - def testTrack(self): - tck = ges.track_video_raw_new() - tl = ges.Timeline() - lyr = ges.TimelineLayer() - src = ges.TimelineTestSource() - caps = gst.caps_from_string("image/jpeg") - obj = ges.TrackParseLaunchEffect ("agingtv") - - tl.add_layer(lyr) - src.add_track_object(obj) - lyr.add_object(src) - tck.set_timeline(tl) - - assert (tck.add_object(obj) == True) - assert (tck.get_timeline() == tl) - tck.set_caps(caps) - assert (tck.get_caps().to_string() == "image/jpeg") diff --git a/bindings/python/testsuite/test_transition.py b/bindings/python/testsuite/test_transition.py deleted file mode 100644 index 993c2491c8..0000000000 --- a/bindings/python/testsuite/test_transition.py +++ /dev/null @@ -1,50 +0,0 @@ -import glib -import gst - -from common import TestCase -import ges - -class Timeline(TestCase): - - def testTimeline(self): - - tl = ges.timeline_new_audio_video() - lyr = ges.SimpleTimelineLayer() - src = ges.TimelineTestSource() - src2 = ges.TimelineTestSource() - tr = ges.TimelineStandardTransition("crossfade") - pip = ges.TimelinePipeline() - bus = pip.get_bus() - self.mainloop = glib.MainLoop() - - # Let's add the layer to the timeline, and the sources - # and transition to the layer. - - tl.add_layer(lyr) - src.set_duration(long(gst.SECOND * 10)) - src2.set_duration(long(gst.SECOND * 10)) - src.set_vpattern("Random (television snow)") - tr.set_duration(long(gst.SECOND * 10)) - - lyr.add_object(src, -1) - lyr.add_object(tr, -1) - assert (lyr.add_object(src2, -1) == True) - - pip.add_timeline(tl) - bus.set_sync_handler(self.bus_handler) - - self.pipeline = pip - self.layer = lyr - - #Mainloop is finished, tear down. - self.pipeline = None - - - def bus_handler(self, unused_bus, message): - if message.type == gst.MESSAGE_ERROR: - print "ERROR" - self.mainloop.quit() - elif message.type == gst.MESSAGE_EOS: - print "Done" - self.mainloop.quit() - return gst.BUS_PASS diff --git a/configure.ac b/configure.ac index 7c3a0b0c82..09adbef539 100644 --- a/configure.ac +++ b/configure.ac @@ -115,57 +115,8 @@ GOBJECT_INTROSPECTION_CHECK([0.9.6]) dnl check for documentation tools AG_GST_DOCBOOK_CHECK GTK_DOC_CHECK([1.3]) -AS_PATH_PYTHON([2.1]) AG_GST_PLUGIN_DOCS([1.3],[2.1]) -dnl check for python -AM_PATH_PYTHON -AC_MSG_CHECKING(for python >= 2.3) -prog=" -import sys, string -minver = (2,3,0,'final',0) -if sys.version_info < minver: - sys.exit(1) -sys.exit(0)" - -if $PYTHON -c "$prog" 1>&AC_FD_CC 2>&AC_FD_CC -then - HAVE_PYTHON=yes - AC_MSG_RESULT(okay) -else - HAVE_PYTHON=no - AC_MSG_RESULT(no python) -fi - -AM_CHECK_PYTHON_HEADERS([HAVE_PYTHON_HEADERS=yes],[HAVE_PYTHON_HEADERS=no]) - -dnl check for pygobject (optional, used in the bindings) -PYGOBJECT_REQ=2.11.2 -PKG_CHECK_MODULES(PYGOBJECT, pygobject-2.0 >= $PYGOBJECT_REQ, - [HAVE_PYGOBJECT="yes"], [HAVE_PYGOBJECT="no"]) -AC_SUBST(PYGOBJECT_CFLAGS) - -dnl check for gst-python -PKG_CHECK_MODULES(PYGST, gst-python-0.10, - [HAVE_PYGST="yes"], [HAVE_PYGST="no"]) - -if test "x$HAVE_PYGST" = "xyes"; then - PYGST_DEFSDIR=`pkg-config gst-python-0.10 --variable=defsdir` -fi -AC_SUBST(PYGST_DEFSDIR, $PYGST_DEFSDIR) - -if test \ - "x$HAVE_PYTHON" = "xyes" -a \ - "x$HAVE_PYTHON_HEADERS" = "xyes" -a \ - "x$HAVE_PYGOBJECT" = "xyes" -a \ - "x$HAVE_PYGST" = "xyes"; then - HAVE_PYTHON_BINDINGS="yes" -else - HAVE_PYTHON_BINDINGS="no" -fi - -AM_CONDITIONAL(WITH_PYTHON, [test "x$HAVE_PYTHON_BINDINGS" = "xyes"]) - dnl *** checks for libraries *** dnl check for libm, for sin() etc. @@ -350,11 +301,6 @@ common/m4/Makefile gst-editing-services.spec m4/Makefile ges/Makefile -bindings/Makefile -bindings/python/Makefile -bindings/python/codegen/Makefile -bindings/python/examples/Makefile -bindings/python/testsuite/Makefile tests/Makefile tests/check/Makefile tests/examples/Makefile