This method creates a new object, so it is necessary to provide a hint
for the wrappers so that they do not leak the object.

This allows the NewIterator() method to return a usable iterator in
Python.

permitted calldata types in python: strings, floats, ints, vtk.vtkObjects

The wrapper-generators used to have a hard-coded list of methods that
returned new vtkObject instances, so that the wrappers could properly
manage the reference counts.  This patch replaces the hard-coded list
with a hint macro that can be used anywhere.

This activates the changes to vtkParse.y that were made in the previous
three commits.

By failing, rather than simply printing a warning, we get insurance
that misspelled attributes won't slip into the code unnoticed.

One of the places where parameter attributes can be provided had been
missed when the VTK wrapper-parser was enhanced for C++11.  This change
is necessary for attributes to be used to provide wrapper hints for
VTK method parameters.

C++ attributes provide a powerful mechanism for adding wrapper hints
to the VTK header files.  VTK-specific attributes will take the form
[[vtk::attribute]] or, eventually, [[vtk::attribute(args)]].
way that compilers use attributes as hints.

These new macros can be used to detect when the headers are being
parsed by one of the wrapper tools, rather than by the C++ compiler:
  __VTK_WRAP_PYTHON__ , __VTK_WRAP_TCL__ , __VTK_WRAP_JAVA__
Also, the old __WRAP__ macro should no longer be used, it has been
replaced with __VTK_WRAP__.

First automatically removed lines with only BTX/ETX
from .h files with the following regexes:

^ *// *BTX\r
^ *// *ETX\r

and replaced occurances with nothing. Committed that, then manually
removed various remaining cases of BTX/ETX, and related comments, and parsing stuff,
then trashed the first commit.

In the Python wrappers, the vtkDataArray::SetVoidArray() method can take
two kinds of arguments:

1) a string formatted as a swig pointer "_addr_type" where "addr" is
the hexadecimal address and "type" is the type, e.g. "p_void".

2) a Python buffer object (any Python object with buffer protocol)

A Python string (in Python 2) is also a buffer object, therefore there
is some ambiguity.  The use of swig pointers with VTK is exceedingly
rare, so this fix requires that the string exactly matches the format
"_addr_p_void" to be interpreted as a swig pointer.

Note that in Python 3, the ambiguity disappears because a string in Py3K
does not have the buffer protocol.

In vtkParse.y, there was no rule for variable initialization via
constructor args, for example "someclass variablename(arglist)".
Unfortunately, this syntax looks similar to function declaration
"someclass functionname(parameterlist)" and leads to ambiguity
because the parser cannot always distinguish between "arglist"
(a list of values) and "parameterlist" (a list of types).

The reason the parser has difficulty with this is that it lacks
the ability to tell which identifiers refer to types, and which
refer to values.  For now the parser demands that "arglist" begins
with a literal, since a literal is always a value.

The ${vtk-module}.py written in the block above this one is preferred
over the ${vtk-module}/__init__.py written here. Just overwrite the
module with the kit module.

Kitware Robot authored Mar 08, 2016 and Dan Lipsa committed Mar 08, 2016

Code extracted from:

    https://gitlab.kitware.com/third-party/proj.git

at commit 41bdf05361007f8c5186f3df9944d86bb273ed13 (for/vtk).

vtkDataArray subclasses now use

ComponentValue --> TypedComponent
TupleValue --> TypedValue

for their type-specific methods.

# Conflicts:
#	Rendering/Annotation/vtkScalarBarActor.cxx

Variables must be declared early in C89.

Some Python scripts explicitly import from named submodules as opposed to from
the top-level vtk module. When VTK_ENABLE_KITS is ON those modules might not
exist. This results in ImportErrors, like the one shown below when running the
vtkFiltersCorePython-pointsPrecisions test:

    Traceback (most recent call last):
      File "C:/dev/VTK/Filters/Core/Testing/Python/pointsPrecisions.py", line 3, in <module>
	from vtk.vtkCommonCore import vtkPoints, vtkDoubleArray, vtkIdList
    ImportError: No module named vtkCommonCore

This commit adds adapter modules to allow such scripts to run unmodified when
VTK_ENABLE_KITS is ON.

To keep the argument parsing code simple, each hierarchy and hint file has to be
specified using a dedicated --types.

This change is backwards compatible. Deprecated members and functions are marked
with "XXX DEPRECATED".
Co-authored-by: Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
Co-authored-by: Max Smolens <max.smolens@kitware.com>

If VTK_ENABLE_KITS is ON, VTK kits and modules that are not associated with any
kit will be wrapped. The effect is that drastically fewer libraries are created.

Take vtkCommon as an example. When VTK_ENABLE_KITS is OFF, a library is
generated for each wrapped module:

    vtkCommonColorPython27D-x.y.dll
    vtkCommonComputationalGeometryPython27D-x.y.dll
    vtkCommonCorePython27D-x.y.dll
    vtkCommonDataModelPython27D-x.y.dll
    vtkCommonExecutionModelPython27D-x.y.dll
    vtkCommonMathPython27D-x.y.dll
    vtkCommonMiscPython27D-x.y.dll
    vtkCommonSystemPython27D-x.y.dll
    vtkCommonTransformsPython27D-x.y.dll

When VTK_ENABLE_KITS is ON, a single "kit" library is generated:

    vtkCommonKitPython27D-x.y.dll

The wrapped kits have the suffix "Kit" to avoid naming conflicts with existing
libraries like "vtkFilterPython".

As part of this change, the Python wrapping function has been split into two
functions, one which wraps the code and another which builds the wrapped code.
The new function is backwards compatible, but to update client code, replace
calls like:

    vtk_add_python_wrapping(${module})

with:

    vtk_add_python_wrapping(${module} module_srcs)
    vtk_add_python_wrapping_library(${module} module_srcs ${module})

Additionally, the functions "vtk_wrap_python" and "vtk_add_python_wrapping" have
been updated to understand a list of modules as input.
Co-authored-by: Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
Co-authored-by: Max Smolens <max.smolens@kitware.com>
Co-authored-by: Ben Boeckel <ben.boeckel@kitware.com>

The help() function was not working on wrapped class templates, so the
PyVTKTemplate type has been re-imagined as a module that contains the
instantiations of the template, since the help() function works with
module docstrings. PyVTKTemplate still supports the mapping protocol
as before, which allows lookup of the instantiated templates via the
template arguments.

After the changes to make this module work with Python 3, it gives the
following error under Python 2.7:

UnboundLocalError: local variable 'unicode' referenced before assignment

Creating a local variable from the builtin 'unicode' fixes the issue.

The check for passthrough "PyObject *" args had an erroneous break
statement, which caused all further args to be ignored.

It has been possible to call help() on instances of VTK classes ever
since new-style classes were provided by the wrappers.

Without this change, parameters like ( , int array[3] = 0) are required
parameters when the method is called from python.

* Use angleDelta() if delta() does not exist (PyQt5)
* Only zoom if cumulative delta is greater/less than +/- 15 degrees

The way algorithms were updated (made to execute) with
request meta-data (such as update extent) was very error
prone and counter-intuitive. Added new methods to make
updating with meta-data easier. I also deprecated a number
of methods to set request meta-data. This will encourage
developers to migrate to the new API which is less error-
prone.

When the python wrappers were wrapping a pointer parameter with a default
value of null, e.g. func(int *x=0), then if no parameter was passed then
the underlying C++ function would receive an uninitialized array rather
a null pointer.

In addition, the SaveArray() and ArrayHasChanged() methods that the python
wrappers use when wrapping non-const pointers and arrays would overflow
when the array size was zero.