Commit ba693ade authored by David Gobbi's avatar David Gobbi

Add an enum type to the python wrappers.

Any enum types that are encountered will automatically be wrapped
as integral types.  This is true for enum types defined in the global
namespace, and enum types defined within a wrapped class.  Other
namespaces are not yet supported, because the python wrappers do not
yet wrap C++ namespaces.

When a class method has an enum parameter, and if the enum is a member
of the class, then that method will perform type checking on the enum.
Class methods that require enums that are not members of the class will
not be wrapped (in future versions of the wrappers, they might).

Change-Id: If38391de8a1a66eb255ddf83a72916af6d81dc78
parent f642f513
......@@ -2,6 +2,7 @@ vtk_add_test_python(
NO_DATA NO_VALID NO_OUTPUT
PythonSmoke.py
TestArrayArguments.py
TestEnums.py
TestExecuteMethodFinalizeCrash.py
TestGhost.py
TestIgnoreBTX.py
......
"""Test enum support in VTK-Python
Created on Nov 13, 2014 by David Gobbi
"""
import sys
import exceptions
import vtk
from vtk.test import Testing
class TestEnum(Testing.vtkTest):
def testGlobalNamespaceEnum(self):
"""Check that an enum in the global namespace was wrapped.
"""
# defined in vtkGenericEnSightReader.h
if hasattr(vtk, 'vtkGenericEnsightReader'):
self.assertEqual(vtk.SINGLE_PROCESS_MODE, 0)
self.assertEqual(vtk.SPARSE_MODE, 1)
self.assertEqual(type(vtk.SINGLE_PROCESS_MODE),
vtk.EnsightReaderCellIdMode)
self.assertEqual(type(vtk.SPARSE_MODE),
vtk.EnsightReaderCellIdMode)
def testClassNamespaceEnum(self):
"""Check that an enum in a class namespace was wrapped.
"""
# defined in vtkColorSeries.h
self.assertEqual(vtk.vtkColorSeries.SPECTRUM, 0)
self.assertEqual(type(vtk.vtkColorSeries.SPECTRUM),
vtk.vtkColorSeries.ColorSchemes)
# defined in vtkErrorCode.h
self.assertEqual(vtk.vtkErrorCode.FirstVTKErrorCode, 20000)
self.assertEqual(type(vtk.vtkErrorCode.FirstVTKErrorCode),
vtk.vtkErrorCode.ErrorIds)
def testAnonymousEnum(self):
"""Check that anonymous enums are wrapped.
"""
# defined in vtkAbstractArray.h
self.assertEqual(vtk.vtkAbstractArray.AbstractArray, 0)
if __name__ == "__main__":
Testing.main([(TestEnum, 'test')])
......@@ -957,10 +957,10 @@ void *vtkPythonArgs::GetArgAsSpecialObject(
return r;
}
int vtkPythonArgs::GetArgAsEnum(const char *s, bool &valid)
int vtkPythonArgs::GetArgAsEnum(PyTypeObject *enumtype, bool &valid)
{
PyObject *o = PyTuple_GET_ITEM(this->Args, this->I++);
int i = vtkPythonArgs::GetArgAsEnum(o, s, valid);
int i = vtkPythonArgs::GetArgAsEnum(o, enumtype, valid);
if (!valid)
{
this->RefineArgTypeError(this->I - this->M - 1);
......@@ -968,12 +968,25 @@ int vtkPythonArgs::GetArgAsEnum(const char *s, bool &valid)
return i;
}
int vtkPythonArgs::GetArgAsEnum(PyObject *o, const char *, bool &valid)
int vtkPythonArgs::GetArgAsEnum(
PyObject *o, PyTypeObject *enumtype, bool &valid)
{
// should check enum type for validity
int i = 0;
valid = (vtkPythonGetValue(o, i) != 0);
return (valid ? i : 0);
long i = 0;
if (o->ob_type == enumtype)
{
i = PyInt_AsLong(o);
valid = true;
}
else
{
std::string errstring = "expected enum ";
errstring += enumtype->tp_name;
errstring += ", got ";
errstring += o->ob_type->tp_name;
PyErr_SetString(PyExc_TypeError, errstring.c_str());
valid = false;
}
return i;
}
......
......@@ -162,14 +162,14 @@ public:
// Description:
// Get the next argument as an enum value.
template<class T>
bool GetEnumValue(T &v, const char *enumname) {
bool GetEnumValue(T &v, PyTypeObject *enumtype) {
bool r;
v = static_cast<T>(this->GetArgAsEnum(enumname, r));
v = static_cast<T>(this->GetArgAsEnum(enumtype, r));
return r; }
template<class T>
static bool GetEnumValue(PyObject *o, T &v, const char *enumname) {
static bool GetEnumValue(PyObject *o, T &v, PyTypeObject *enumtype) {
bool r;
v = static_cast<T>(vtkPythonArgs::GetArgAsEnum(o, enumname, r));
v = static_cast<T>(vtkPythonArgs::GetArgAsEnum(o, enumtype, r));
return r; }
// Description:
......@@ -521,9 +521,9 @@ protected:
// Description:
// Get the next argument as an object of the given type.
int GetArgAsEnum(const char *classname, bool &valid);
int GetArgAsEnum(PyTypeObject *enumtype, bool &valid);
static int GetArgAsEnum(
PyObject *o, const char *classname, bool &valid);
PyObject *o, PyTypeObject *enumtype, bool &valid);
// Description:
// Get the next argument as an object of the given type.
......
......@@ -612,6 +612,25 @@ int vtkPythonOverload::CheckArg(
}
}
// Enum type
else if (isalpha(classname[0]) ||
(classname[0] == '&' && isalpha(classname[1])))
{
if (classname[0] == '&')
{
classname++;
}
if (PyInt_Check(arg) &&
strcmp(arg->ob_type->tp_name, classname) == 0)
{
penalty = VTK_PYTHON_EXACT_MATCH;
}
else
{
penalty = VTK_PYTHON_INCOMPATIBLE;
}
}
// An array
else if (classname[0] == '*')
{
......
......@@ -75,6 +75,7 @@ if(NOT CMAKE_CROSSCOMPILING)
vtkWrapPython.c
vtkWrapPythonClass.c
vtkWrapPythonConstant.c
vtkWrapPythonEnum.c
vtkWrapPythonMethod.c
vtkWrapPythonMethodDef.c
vtkWrapPythonOverload.c
......
......@@ -285,6 +285,28 @@ int vtkWrap_IsConst(ValueInfo *val)
return ((val->Type & VTK_PARSE_CONST) != 0);
}
/* -------------------------------------------------------------------- */
/* Check if the arg type is an enum that is a member of the class */
int vtkWrap_IsEnumMember(ClassInfo *data, ValueInfo *arg)
{
int i;
if (arg->Class)
{
/* check if the enum is a member of the class */
for (i = 0; i < data->NumberOfEnums; i++)
{
EnumInfo *info = data->Enums[i];
if (info->Name && strcmp(arg->Class, info->Name) == 0)
{
return 1;
}
}
}
return 0;
}
/* -------------------------------------------------------------------- */
/* Hints */
......@@ -864,10 +886,13 @@ const char *vtkWrap_GetTypeName(ValueInfo *val)
/* variable declarations */
void vtkWrap_DeclareVariable(
FILE *fp, ValueInfo *val, const char *name, int i, int flags)
FILE *fp, ClassInfo *data, ValueInfo *val, const char *name,
int i, int flags)
{
unsigned int aType;
int j;
const char *typeName;
char *newTypeName = NULL;
if (val == NULL)
{
......@@ -883,7 +908,27 @@ void vtkWrap_DeclareVariable(
return;
}
/* add a couple spaces */
typeName = vtkWrap_GetTypeName(val);
if (vtkWrap_IsEnumMember(data, val))
{
/* use a typedef to work around compiler issues when someone used
the same name for the enum type as for a variable or method */
newTypeName = (char *)malloc(strlen(name) + 16);
if (i >= 0)
{
sprintf(newTypeName, "%s%i_type", name, i);
}
else
{
sprintf(newTypeName, "%s_type", name);
}
fprintf(fp, " typedef %s::%s %s;\n",
data->Name, typeName, newTypeName);
typeName = newTypeName;
}
/* add a couple spaces for indentation*/
fprintf(fp," ");
/* for const * return types, prepend with const */
......@@ -909,7 +954,7 @@ void vtkWrap_DeclareVariable(
}
/* print the type name */
fprintf(fp, "%s ", vtkWrap_GetTypeName(val));
fprintf(fp, "%s ", typeName);
/* indirection */
if ((flags & VTK_WRAP_RETURN) != 0)
......@@ -1004,6 +1049,8 @@ void vtkWrap_DeclareVariable(
{
fprintf(fp, ";\n");
}
free(newTypeName);
}
void vtkWrap_DeclareVariableSize(
......
......@@ -133,6 +133,11 @@ int vtkWrap_IsSpecialType(
int vtkWrap_IsTypeOf(
HierarchyInfo *hinfo, const char *classname, const char *superclass);
/**
* Check if the type of the value is an enum member of the class.
*/
int vtkWrap_IsEnumMember(ClassInfo *data, ValueInfo *arg);
/**
* Check whether a class is wrapped. If "hinfo" is NULL,
* it just checks that the class starts with "vtk".
......@@ -233,7 +238,8 @@ int vtkWrap_CountRequiredArguments(FunctionInfo *f);
* - "const" is removed except for return values with "&" or "*".
*/
void vtkWrap_DeclareVariable(
FILE *fp, ValueInfo *v, const char *name, int idx, int flags);
FILE *fp, ClassInfo *data, ValueInfo *v, const char *name,
int idx, int flags);
/**
* Write an "int" size variable for arrays, initialized to
......
......@@ -15,6 +15,7 @@
#include "vtkWrapPythonClass.h"
#include "vtkWrapPythonConstant.h"
#include "vtkWrapPythonEnum.h"
#include "vtkWrapPythonMethodDef.h"
#include "vtkWrap.h"
......@@ -147,7 +148,7 @@ static void vtkWrapPython_GenerateSpecialHeaders(
for (i = 0; i < n; i++)
{
currentFunction = data->Functions[i];
if (vtkWrapPython_MethodCheck(currentFunction, hinfo))
if (vtkWrapPython_MethodCheck(data, currentFunction, hinfo))
{
classname = "void";
aType = VTK_PARSE_VOID;
......@@ -365,6 +366,12 @@ int main(int argc, char *argv[])
"extern \"C\" { %s void PyVTKAddFile_%s(PyObject *, const char *); }\n",
"VTK_ABI_EXPORT", name);
/* Wrap any enum types defined in the global namespace */
for (i = 0; i < contents->NumberOfEnums; i++)
{
vtkWrapPython_GenerateEnumType(fp, NULL, contents->Enums[i]);
}
/* Check for all special classes before any classes are wrapped */
for (i = 0; i < contents->NumberOfClasses; i++)
{
......@@ -498,10 +505,19 @@ int main(int argc, char *argv[])
data->Name);
}
/* add any enum types defined in the file */
for (j = 0; j < contents->NumberOfEnums; j++)
{
vtkWrapPython_AddEnumType(
fp, " ", "dict", "o", NULL, contents->Enums[j]);
fprintf(fp, "\n");
}
/* add any constants defined in the file */
for (j = 0; j < contents->NumberOfConstants; j++)
{
vtkWrapPython_AddConstant(fp, " ", "dict", "o", contents->Constants[j]);
vtkWrapPython_AddConstant(fp, " ", "dict", "o", NULL,
contents->Constants[j]);
fprintf(fp, "\n");
}
......
......@@ -15,6 +15,7 @@
#include "vtkWrapPythonClass.h"
#include "vtkWrapPythonConstant.h"
#include "vtkWrapPythonEnum.h"
#include "vtkWrapPythonMethodDef.h"
#include "vtkWrapPythonTemplate.h"
#include "vtkWrapPythonType.h"
......@@ -286,7 +287,7 @@ void vtkWrapPython_ClassDoc(
{
for (j = 0; j < data->NumberOfFunctions; j++)
{
if (vtkWrapPython_MethodCheck(data->Functions[j], hinfo) &&
if (vtkWrapPython_MethodCheck(data, data->Functions[j], hinfo) &&
vtkWrap_IsConstructor(data, data->Functions[j]))
{
fprintf(fp," \"%s\\n\",\n",
......@@ -421,13 +422,24 @@ static void vtkWrapPython_GenerateObjectNew(
" PyObject *o;\n"
"\n");
/* add any enum types defined in the class to its dict */
for (i = 0; i < data->NumberOfEnums; i++)
{
if (data->Enums[i]->Access == VTK_ACCESS_PUBLIC)
{
vtkWrapPython_AddEnumType(
fp, " ", "d", "o", data->Name, data->Enums[i]);
fprintf(fp, "\n");
}
}
/* add any constants defined in the class to its dict */
for (i = 0; i < data->NumberOfConstants; i++)
{
if (data->Constants[i]->Access == VTK_ACCESS_PUBLIC)
{
vtkWrapPython_AddConstant(
fp, " ", "d", "o", data->Constants[i]);
fp, " ", "d", "o", data->Name, data->Constants[i]);
fprintf(fp, "\n");
}
}
......@@ -489,6 +501,16 @@ int vtkWrapPython_WrapOneClass(
}
}
/* create any enum types defined in the class */
for (i = 0; i < data->NumberOfEnums; i++)
{
if (data->Enums[i]->Access == VTK_ACCESS_PUBLIC)
{
vtkWrapPython_GenerateEnumType(
fp, classname, data->Enums[i]);
}
}
/* now output all the methods are wrappable */
if (is_vtkobject || !data->IsAbstract)
{
......
......@@ -29,14 +29,16 @@
void vtkWrapPython_AddConstant(
FILE *fp, const char *indent, const char *dictvar, const char *objvar,
ValueInfo *val)
const char *scope, ValueInfo *val)
{
unsigned int valtype;
const char *valstring;
const char *valname;
int objcreated = 0;
valtype = (val->Type & VTK_PARSE_UNQUALIFIED_TYPE);
valstring = val->Value;
valname = val->Name;
if (valtype == 0 && (valstring == NULL || valstring[0] == '\0'))
{
......@@ -52,7 +54,28 @@ void vtkWrapPython_AddConstant(
return;
}
switch (valtype)
if (val->IsEnum)
{
if (val->Class && val->Class[0] != '\0' &&
strcmp(val->Class, "int") != 0)
{
fprintf(fp,
"%s%s = Py%s%s%s_FromEnum(%s%s%s);\n",
indent, objvar,
(scope ? scope : ""), (scope ? "_" : ""), val->Class,
(scope ? scope : ""), (scope ? "::" : ""), valname);
objcreated = 1;
}
else
{
fprintf(fp,
"%s%s = PyInt_FromLong(%s%s%s);\n",
indent, objvar,
(scope ? scope : ""), (scope ? "::" : ""), valname);
objcreated = 1;
}
}
else switch (valtype)
{
case VTK_PARSE_VOID:
fprintf(fp,
......
......@@ -20,9 +20,9 @@
#include "vtkParseData.h"
#include "vtkParseHierarchy.h"
/* Generate code that add a constant value to a python dict */
/* generate code that adds a constant value to a python dict */
void vtkWrapPython_AddConstant(
FILE *fp, const char *indent, const char *dictvar, const char *objvar,
ValueInfo *val);
const char *scope, ValueInfo *val);
#endif /* VTK_WRAP_PYTHON_CONSTANT_H */
/*=========================================================================
Program: Visualization Toolkit
Module: vtkWrapPythonEnum.c
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkWrapPythonEnum.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
void vtkWrapPython_AddEnumType(
FILE *fp, const char *indent, const char *dictvar, const char *objvar,
const char *scope, EnumInfo *cls)
{
/* Don't add anonymous enums */
fprintf(fp,
"%sPyType_Ready(&Py%s%s%s_Type);\n"
"%sPy%s%s%s_Type.tp_new = NULL;\n"
"\n",
indent, (scope ? scope : ""), (scope ? "_" : ""), cls->Name,
indent, (scope ? scope : ""), (scope ? "_" : ""), cls->Name);
fprintf(fp,
"%s%s = (PyObject *)&Py%s%s%s_Type;\n"
"%sif (%s && PyDict_SetItemString(%s, (char *)\"%s\", %s) != 0)\n"
"%s {\n"
"%s Py_DECREF(%s);\n"
"%s }\n",
indent, objvar,
(scope ? scope : ""), (scope ? "_" : ""), cls->Name,
indent, objvar, dictvar, cls->Name, objvar,
indent,
indent, objvar,
indent);
}
/* -------------------------------------------------------------------- */
/* write out an enum type object */
void vtkWrapPython_GenerateEnumType(
FILE *fp, const char *classname, EnumInfo *data)
{
char enumname[1024];
size_t classnamelen = 0;
if (classname)
{
classnamelen = strlen(classname);
strcpy(enumname, classname);
enumname[classnamelen] = '_';
strcpy(enumname+classnamelen+1, data->Name);
}
else
{
strcpy(enumname, data->Name);
}
/* forward declaration of the type object */
fprintf(fp,
"#ifndef DECLARED_Py%s_Type\n"
"extern %s PyTypeObject Py%s_Type;\n"
"#define DECLARED_Py%s_Type\n"
"#endif\n"
"\n",
enumname, "VTK_ABI_EXPORT", enumname, enumname);
/* generate all functions and protocols needed for the type */
/* generate the TypeObject */
fprintf(fp,
"PyTypeObject Py%s_Type = {\n"
" PyObject_HEAD_INIT(&PyType_Type)\n"
" 0,\n"
" (char*)\"%s\", // tp_name\n"
" sizeof(PyIntObject), // tp_basicsize\n"
" 0, // tp_itemsize\n"
" 0, // tp_dealloc\n"
" 0, // tp_print\n"
" 0, // tp_getattr\n"
" 0, // tp_setattr\n"
" 0, // tp_compare\n"
" 0, // tp_repr\n",
enumname, data->Name);
fprintf(fp,
" 0, // tp_as_number\n"
" 0, // tp_as_sequence\n"
" 0, // tp_as_mapping\n"
" 0, // tp_hash\n"
" 0, // tp_call\n"
" 0, // tp_str\n"
" 0, // tp_getattro\n"
" 0, // tp_setattro\n"
" 0, // tp_as_buffer\n"
" Py_TPFLAGS_DEFAULT, // tp_flags\n"
" 0, // tp_doc\n"
" 0, // tp_traverse\n"
" 0, // tp_clear\n"
" 0, // tp_richcompare\n"
" 0, // tp_weaklistoffset\n");
fprintf(fp,
" 0, // tp_iter\n"
" 0, // tp_iternext\n"
" 0, // tp_methods\n"
" 0, // tp_members\n"
" 0, // tp_getset\n"
" &PyInt_Type, // tp_base\n"
" 0, // tp_dict\n"
" 0, // tp_descr_get\n"
" 0, // tp_descr_set\n"
" 0, // tp_dictoffset\n"
" 0, // tp_init\n"
" 0, // tp_alloc\n"
" 0, // tp_new\n"
" PyObject_Del, // tp_free\n"
" 0, // tp_is_gc\n");
/* fields set by python itself */
fprintf(fp,
" 0, // tp_bases\n"
" 0, // tp_mro\n"
" 0, // tp_cache\n"
" 0, // tp_subclasses\n"
" 0, // tp_weaklist\n");
/* internal struct members */
fprintf(fp,
" VTK_WRAP_PYTHON_SUPRESS_UNINITIALIZED\n"
"};\n"
"\n");
/* conversion method: construct from enum value */
fprintf(fp,
"PyObject *Py%s_FromEnum(int val)\n"
"{\n"
" PyIntObject *self = PyObject_New(PyIntObject,\n"
" &Py%s_Type);\n"
" self->ob_ival = val;\n"
" return (PyObject *)self;\n"
"}\n"
"\n",
enumname,
enumname);
}
/*=========================================================================
Program: Visualization Toolkit
Module: vtkWrapPythonEnum.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#ifndef VTK_WRAP_PYTHON_ENUM_H
#define VTK_WRAP_PYTHON_ENUM_H
#include "vtkParse.h"
#include "vtkParseData.h"
#include "vtkParseHierarchy.h"
/* write out an enum type wrapped in python */
void vtkWrapPython_GenerateEnumType(
FILE *fp, const char *classname, EnumInfo *data);
/* generate code that adds an enum type to a python dict */
void vtkWrapPython_AddEnumType(
FILE *fp, const char *indent, const char *dictvar, const char *objvar,
const char *scope, EnumInfo *cls);
#endif /* VTK_WRAP_PYTHON_ENUM_H */
......@@ -33,7 +33,7 @@ static void vtkWrapPython_GetSizesForArrays(
/* Write the code to convert the arguments with vtkPythonArgs */
static void vtkWrapPython_GetAllParameters(
FILE *fp, FunctionInfo *currentFunction);
FILE *fp, ClassInfo *data, FunctionInfo *currentFunction);
/* save the contents of all arrays prior to calling the function */
static void vtkWrapPython_SaveArrayArgs(
......@@ -69,7 +69,7 @@ static int vtkWrapPython_CountAllOccurrences(
/* -------------------------------------------------------------------- */
/* Declare all local variables used by the wrapper method */
void vtkWrapPython_DeclareVariables(
FILE *fp, FunctionInfo *theFunc)
FILE *fp, ClassInfo *data, FunctionInfo *theFunc)
{
ValueInfo *arg;
int i, n;
......@@ -93,7 +93,7 @@ void vtkWrapPython_DeclareVariables(
}
/* make a "temp" variable for the argument */
vtkWrap_DeclareVariable(fp, arg, "temp", i, VTK_WRAP_ARG);
vtkWrap_DeclareVariable(fp, data, arg, "temp", i, VTK_WRAP_ARG);
/* temps for conversion constructed objects, which only occur
* for special objects */
......@@ -114,7 +114,7 @@ void vtkWrapPython_DeclareVariables(
!vtkWrap_IsSetVectorMethod(theFunc))
{
/* for saving a copy of the array */
vtkWrap_DeclareVariable(fp, arg, "save", i, VTK_WRAP_ARG);
vtkWrap_DeclareVariable(fp, data, arg, "save", i, VTK_WRAP_ARG);
storageSize *= 2;
}
if (arg->CountHint || vtkWrap_IsPODPointer(arg))
......@@ -228,7 +228,7 @@ static void vtkWrapPython_GetSizesForArrays(
/* -------------------------------------------------------------------- */
/* Write the code to convert one argument with vtkPythonArgs */
void vtkWrapPython_GetSingleArgument(
FILE *fp, int i, ValueInfo *arg, int static_call)
FILE *fp, ClassInfo *data, int i, ValueInfo *arg, int static_call)
{
const char *prefix = "ap.";
char argname[32];
......@@ -241,7 +241,12 @@ void vtkWrapPython_GetSingleArgument(
sprintf(argname, "arg%d, ", i);
}
if (vtkWrap_IsPythonObject(arg))
if (vtkWrap_IsEnumMember(data, arg))
{
fprintf(fp, "%sGetEnumValue(%stemp%d, &Py%s_%s_Type)",
prefix, argname, i, data->Name, arg->Class);
}
else if (vtkWrap_IsPythonObject(arg))
{
fprintf(fp, "%s%sGetPythonObject(temp%d)",
prefix, argname, i);
......@@ -328,7 +333,7 @@ void vtkWrapPython_GetSingleArgument(
/* -------------------------------------------------------------------- */
/* Write the code to convert the arguments with vtkPythonArgs */
static void vtkWrapPython_GetAllParameters(
FILE *fp, FunctionInfo *currentFunction)
FILE *fp, ClassInfo *data, FunctionInfo *currentFunction)
{
ValueInfo *arg;
int requiredArgs, totalArgs;
......@@ -362,7 +367,7 @@ static void vtkWrapPython_GetAllParameters(
fprintf(fp, "(ap.NoArgsLeft() || ");
}
vtkWrapPython_GetSingleArgument(fp, i, arg, 0);
vtkWrapPython_GetSingleArgument(fp, data, i, arg, 0);
if (i >= requiredArgs)
{
......@@ -380,7 +385,7 @@ static void vtkWrapPython_GetAllParameters(
/* -------------------------------------------------------------------- */
/* Convert values into python object and return them within python */
void vtkWrapPython_ReturnValue(