ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 252 insertions, 224 deletions

diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
index 3bef47efd17..7ca783d9aa4 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
@@ -35,336 +35,364 @@ extern "C" {
 /*----------------------FEdge methods ----------------------------*/
 
 PyDoc_STRVAR(FEdge_doc,
-"Class hierarchy: :class:`Interface1D` > :class:`FEdge`\n"
-"\n"
-"Base Class for feature edges.  This FEdge can represent a silhouette,\n"
-"a crease, a ridge/valley, a border or a suggestive contour.  For\n"
-"silhouettes, the FEdge is oriented so that the visible face lies on\n"
-"the left of the edge.  For borders, the FEdge is oriented so that the\n"
-"face lies on the left of the edge.  An FEdge can represent an initial\n"
-"edge of the mesh or runs across a face of the initial mesh depending\n"
-"on the smoothness or sharpness of the mesh.  This class is specialized\n"
-"into a smooth and a sharp version since their properties slightly vary\n"
-"from one to the other.\n"
-"\n"
-".. method:: FEdge()\n"
-"\n"
-"   Default constructor.\n"
-"\n"
-".. method:: FEdge(brother)\n"
-"\n"
-"   Copy constructor.\n"
-"\n"
-"   :arg brother: An FEdge object.\n"
-"   :type brother: :class:`FEdge`\n"
-"\n"
-".. method:: FEdge(first_vertex, second_vertex)\n"
-"\n"
-"   Builds an FEdge going from the first vertex to the second.\n"
-"\n"
-"   :arg first_vertex: The first SVertex.\n"
-"   :type first_vertex: :class:`SVertex`\n"
-"   :arg second_vertex: The second SVertex.\n"
-"   :type second_vertex: :class:`SVertex`");
+             "Class hierarchy: :class:`Interface1D` > :class:`FEdge`\n"
+             "\n"
+             "Base Class for feature edges.  This FEdge can represent a silhouette,\n"
+             "a crease, a ridge/valley, a border or a suggestive contour.  For\n"
+             "silhouettes, the FEdge is oriented so that the visible face lies on\n"
+             "the left of the edge.  For borders, the FEdge is oriented so that the\n"
+             "face lies on the left of the edge.  An FEdge can represent an initial\n"
+             "edge of the mesh or runs across a face of the initial mesh depending\n"
+             "on the smoothness or sharpness of the mesh.  This class is specialized\n"
+             "into a smooth and a sharp version since their properties slightly vary\n"
+             "from one to the other.\n"
+             "\n"
+             ".. method:: FEdge()\n"
+             "\n"
+             "   Default constructor.\n"
+             "\n"
+             ".. method:: FEdge(brother)\n"
+             "\n"
+             "   Copy constructor.\n"
+             "\n"
+             "   :arg brother: An FEdge object.\n"
+             "   :type brother: :class:`FEdge`\n"
+             "\n"
+             ".. method:: FEdge(first_vertex, second_vertex)\n"
+             "\n"
+             "   Builds an FEdge going from the first vertex to the second.\n"
+             "\n"
+             "   :arg first_vertex: The first SVertex.\n"
+             "   :type first_vertex: :class:`SVertex`\n"
+             "   :arg second_vertex: The second SVertex.\n"
+             "   :type second_vertex: :class:`SVertex`");
 
 static int FEdge_init(BPy_FEdge *self, PyObject *args, PyObject *kwds)
 {
-	static const char *kwlist_1[] = {"brother", NULL};
-	static const char *kwlist_2[] = {"first_vertex", "second_vertex", NULL};
-	PyObject *obj1 = 0, *obj2 = 0;
-
-	if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &FEdge_Type, &obj1)) {
-		if (!obj1)
-			self->fe = new FEdge();
-		else
-			self->fe = new FEdge(*(((BPy_FEdge *)obj1)->fe));
-	}
-	else if (PyErr_Clear(),
-	         PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", (char **)kwlist_2,
-	                                     &SVertex_Type, &obj1, &SVertex_Type, &obj2))
-	{
-		self->fe = new FEdge(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv);
-	}
-	else {
-		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
-		return -1;
-	}
-	self->py_if1D.if1D = self->fe;
-	self->py_if1D.borrowed = false;
-	return 0;
+  static const char *kwlist_1[] = {"brother", NULL};
+  static const char *kwlist_2[] = {"first_vertex", "second_vertex", NULL};
+  PyObject *obj1 = 0, *obj2 = 0;
+
+  if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &FEdge_Type, &obj1)) {
+    if (!obj1)
+      self->fe = new FEdge();
+    else
+      self->fe = new FEdge(*(((BPy_FEdge *)obj1)->fe));
+  }
+  else if (PyErr_Clear(),
+           PyArg_ParseTupleAndKeywords(args,
+                                       kwds,
+                                       "O!O!",
+                                       (char **)kwlist_2,
+                                       &SVertex_Type,
+                                       &obj1,
+                                       &SVertex_Type,
+                                       &obj2)) {
+    self->fe = new FEdge(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv);
+  }
+  else {
+    PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
+    return -1;
+  }
+  self->py_if1D.if1D = self->fe;
+  self->py_if1D.borrowed = false;
+  return 0;
 }
 
 /*----------------------FEdge sequence protocol ----------------------------*/
 
 static Py_ssize_t FEdge_sq_length(BPy_FEdge * /*self*/)
 {
-	return 2;
+  return 2;
 }
 
 static PyObject *FEdge_sq_item(BPy_FEdge *self, int keynum)
 {
-	if (keynum < 0)
-		keynum += FEdge_sq_length(self);
-	if (keynum == 0 || keynum == 1) {
-		SVertex *v = self->fe->operator[](keynum);
-		if (v)
-			return BPy_SVertex_from_SVertex(*v);
-		Py_RETURN_NONE;
-	}
-	PyErr_Format(PyExc_IndexError, "FEdge[index]: index %d out of range", keynum);
-	return NULL;
+  if (keynum < 0)
+    keynum += FEdge_sq_length(self);
+  if (keynum == 0 || keynum == 1) {
+    SVertex *v = self->fe->operator[](keynum);
+    if (v)
+      return BPy_SVertex_from_SVertex(*v);
+    Py_RETURN_NONE;
+  }
+  PyErr_Format(PyExc_IndexError, "FEdge[index]: index %d out of range", keynum);
+  return NULL;
 }
 
 static PySequenceMethods BPy_FEdge_as_sequence = {
-	(lenfunc)FEdge_sq_length,     /* sq_length */
-	NULL,                         /* sq_concat */
-	NULL,                         /* sq_repeat */
-	(ssizeargfunc)FEdge_sq_item,  /* sq_item */
-	NULL,                         /* sq_slice */
-	NULL,                         /* sq_ass_item */
-	NULL,                         /* *was* sq_ass_slice */
-	NULL,                         /* sq_contains */
-	NULL,                         /* sq_inplace_concat */
-	NULL,                         /* sq_inplace_repeat */
+    (lenfunc)FEdge_sq_length,    /* sq_length */
+    NULL,                        /* sq_concat */
+    NULL,                        /* sq_repeat */
+    (ssizeargfunc)FEdge_sq_item, /* sq_item */
+    NULL,                        /* sq_slice */
+    NULL,                        /* sq_ass_item */
+    NULL,                        /* *was* sq_ass_slice */
+    NULL,                        /* sq_contains */
+    NULL,                        /* sq_inplace_concat */
+    NULL,                        /* sq_inplace_repeat */
 };
 
 /*----------------------FEdge get/setters ----------------------------*/
 
 PyDoc_STRVAR(FEdge_first_svertex_doc,
-"The first SVertex constituting this FEdge.\n"
-"\n"
-":type: :class:`SVertex`");
+             "The first SVertex constituting this FEdge.\n"
+             "\n"
+             ":type: :class:`SVertex`");
 
 static PyObject *FEdge_first_svertex_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	SVertex *A = self->fe->vertexA();
-	if (A)
-		return BPy_SVertex_from_SVertex(*A);
-	Py_RETURN_NONE;
+  SVertex *A = self->fe->vertexA();
+  if (A)
+    return BPy_SVertex_from_SVertex(*A);
+  Py_RETURN_NONE;
 }
 
 static int FEdge_first_svertex_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_SVertex_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
-		return -1;
-	}
-	self->fe->setVertexA(((BPy_SVertex *)value)->sv);
-	return 0;
+  if (!BPy_SVertex_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+    return -1;
+  }
+  self->fe->setVertexA(((BPy_SVertex *)value)->sv);
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_second_svertex_doc,
-"The second SVertex constituting this FEdge.\n"
-"\n"
-":type: :class:`SVertex`");
+             "The second SVertex constituting this FEdge.\n"
+             "\n"
+             ":type: :class:`SVertex`");
 
 static PyObject *FEdge_second_svertex_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	SVertex *B = self->fe->vertexB();
-	if (B)
-		return BPy_SVertex_from_SVertex(*B);
-	Py_RETURN_NONE;
+  SVertex *B = self->fe->vertexB();
+  if (B)
+    return BPy_SVertex_from_SVertex(*B);
+  Py_RETURN_NONE;
 }
 
 static int FEdge_second_svertex_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_SVertex_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
-		return -1;
-	}
-	self->fe->setVertexB(((BPy_SVertex *)value)->sv);
-	return 0;
+  if (!BPy_SVertex_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+    return -1;
+  }
+  self->fe->setVertexB(((BPy_SVertex *)value)->sv);
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_next_fedge_doc,
-"The FEdge following this one in the ViewEdge.  The value is None if\n"
-"this FEdge is the last of the ViewEdge.\n"
-"\n"
-":type: :class:`FEdge`");
+             "The FEdge following this one in the ViewEdge.  The value is None if\n"
+             "this FEdge is the last of the ViewEdge.\n"
+             "\n"
+             ":type: :class:`FEdge`");
 
 static PyObject *FEdge_next_fedge_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	FEdge *fe = self->fe->nextEdge();
-	if (fe)
-		return Any_BPy_FEdge_from_FEdge(*fe);
-	Py_RETURN_NONE;
+  FEdge *fe = self->fe->nextEdge();
+  if (fe)
+    return Any_BPy_FEdge_from_FEdge(*fe);
+  Py_RETURN_NONE;
 }
 
 static int FEdge_next_fedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_FEdge_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be an FEdge");
-		return -1;
-	}
-	self->fe->setNextEdge(((BPy_FEdge *)value)->fe);
-	return 0;
+  if (!BPy_FEdge_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be an FEdge");
+    return -1;
+  }
+  self->fe->setNextEdge(((BPy_FEdge *)value)->fe);
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_previous_fedge_doc,
-"The FEdge preceding this one in the ViewEdge.  The value is None if\n"
-"this FEdge is the first one of the ViewEdge.\n"
-"\n"
-":type: :class:`FEdge`");
+             "The FEdge preceding this one in the ViewEdge.  The value is None if\n"
+             "this FEdge is the first one of the ViewEdge.\n"
+             "\n"
+             ":type: :class:`FEdge`");
 
 static PyObject *FEdge_previous_fedge_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	FEdge *fe = self->fe->previousEdge();
-	if (fe)
-		return Any_BPy_FEdge_from_FEdge(*fe);
-	Py_RETURN_NONE;
+  FEdge *fe = self->fe->previousEdge();
+  if (fe)
+    return Any_BPy_FEdge_from_FEdge(*fe);
+  Py_RETURN_NONE;
 }
 
 static int FEdge_previous_fedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_FEdge_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be an FEdge");
-		return -1;
-	}
-	self->fe->setPreviousEdge(((BPy_FEdge *)value)->fe);
-	return 0;
+  if (!BPy_FEdge_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be an FEdge");
+    return -1;
+  }
+  self->fe->setPreviousEdge(((BPy_FEdge *)value)->fe);
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_viewedge_doc,
-"The ViewEdge to which this FEdge belongs to.\n"
-"\n"
-":type: :class:`ViewEdge`");
+             "The ViewEdge to which this FEdge belongs to.\n"
+             "\n"
+             ":type: :class:`ViewEdge`");
 
 static PyObject *FEdge_viewedge_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	ViewEdge *ve = self->fe->viewedge();
-	if (ve)
-		return BPy_ViewEdge_from_ViewEdge(*ve);
-	Py_RETURN_NONE;
+  ViewEdge *ve = self->fe->viewedge();
+  if (ve)
+    return BPy_ViewEdge_from_ViewEdge(*ve);
+  Py_RETURN_NONE;
 }
 
 static int FEdge_viewedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_ViewEdge_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be an ViewEdge");
-		return -1;
-	}
-	self->fe->setViewEdge(((BPy_ViewEdge *)value)->ve);
-	return 0;
+  if (!BPy_ViewEdge_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be an ViewEdge");
+    return -1;
+  }
+  self->fe->setViewEdge(((BPy_ViewEdge *)value)->ve);
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_is_smooth_doc,
-"True if this FEdge is a smooth FEdge.\n"
-"\n"
-":type: bool");
+             "True if this FEdge is a smooth FEdge.\n"
+             "\n"
+             ":type: bool");
 
 static PyObject *FEdge_is_smooth_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	return PyBool_from_bool(self->fe->isSmooth());
+  return PyBool_from_bool(self->fe->isSmooth());
 }
 
 static int FEdge_is_smooth_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!PyBool_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be boolean");
-		return -1;
-	}
-	self->fe->setSmooth(bool_from_PyBool(value));
-	return 0;
+  if (!PyBool_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be boolean");
+    return -1;
+  }
+  self->fe->setSmooth(bool_from_PyBool(value));
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_id_doc,
-"The Id of this FEdge.\n"
-"\n"
-":type: :class:`Id`");
+             "The Id of this FEdge.\n"
+             "\n"
+             ":type: :class:`Id`");
 
 static PyObject *FEdge_id_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	Id id(self->fe->getId());
-	return BPy_Id_from_Id(id); // return a copy
+  Id id(self->fe->getId());
+  return BPy_Id_from_Id(id);  // return a copy
 }
 
 static int FEdge_id_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_Id_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be an Id");
-		return -1;
-	}
-	self->fe->setId(*(((BPy_Id *)value)->id));
-	return 0;
+  if (!BPy_Id_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be an Id");
+    return -1;
+  }
+  self->fe->setId(*(((BPy_Id *)value)->id));
+  return 0;
 }
 
 PyDoc_STRVAR(FEdge_nature_doc,
-"The nature of this FEdge.\n"
-"\n"
-":type: :class:`Nature`");
+             "The nature of this FEdge.\n"
+             "\n"
+             ":type: :class:`Nature`");
 
 static PyObject *FEdge_nature_get(BPy_FEdge *self, void *UNUSED(closure))
 {
-	return BPy_Nature_from_Nature(self->fe->getNature());
+  return BPy_Nature_from_Nature(self->fe->getNature());
 }
 
 static int FEdge_nature_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
 {
-	if (!BPy_Nature_Check(value)) {
-		PyErr_SetString(PyExc_TypeError, "value must be a Nature");
-		return -1;
-	}
-	self->fe->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i));
-	return 0;
+  if (!BPy_Nature_Check(value)) {
+    PyErr_SetString(PyExc_TypeError, "value must be a Nature");
+    return -1;
+  }
+  self->fe->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i));
+  return 0;
 }
 
 static PyGetSetDef BPy_FEdge_getseters[] = {
-	{(char *)"first_svertex", (getter)FEdge_first_svertex_get, (setter)FEdge_first_svertex_set,
-	                          (char *)FEdge_first_svertex_doc, NULL},
-	{(char *)"second_svertex", (getter)FEdge_second_svertex_get, (setter)FEdge_second_svertex_set,
-	                           (char *)FEdge_second_svertex_doc, NULL},
-	{(char *)"next_fedge", (getter)FEdge_next_fedge_get, (setter)FEdge_next_fedge_set,
-	                       (char *)FEdge_next_fedge_doc, NULL},
-	{(char *)"previous_fedge", (getter)FEdge_previous_fedge_get, (setter)FEdge_previous_fedge_set,
-	                           (char *)FEdge_previous_fedge_doc, NULL},
-	{(char *)"viewedge", (getter)FEdge_viewedge_get, (setter)FEdge_viewedge_set, (char *)FEdge_viewedge_doc, NULL},
-	{(char *)"is_smooth", (getter)FEdge_is_smooth_get, (setter)FEdge_is_smooth_set, (char *)FEdge_is_smooth_doc, NULL},
-	{(char *)"id", (getter)FEdge_id_get, (setter)FEdge_id_set, (char *)FEdge_id_doc, NULL},
-	{(char *)"nature", (getter)FEdge_nature_get, (setter)FEdge_nature_set, (char *)FEdge_nature_doc, NULL},
-	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
+    {(char *)"first_svertex",
+     (getter)FEdge_first_svertex_get,
+     (setter)FEdge_first_svertex_set,
+     (char *)FEdge_first_svertex_doc,
+     NULL},
+    {(char *)"second_svertex",
+     (getter)FEdge_second_svertex_get,
+     (setter)FEdge_second_svertex_set,
+     (char *)FEdge_second_svertex_doc,
+     NULL},
+    {(char *)"next_fedge",
+     (getter)FEdge_next_fedge_get,
+     (setter)FEdge_next_fedge_set,
+     (char *)FEdge_next_fedge_doc,
+     NULL},
+    {(char *)"previous_fedge",
+     (getter)FEdge_previous_fedge_get,
+     (setter)FEdge_previous_fedge_set,
+     (char *)FEdge_previous_fedge_doc,
+     NULL},
+    {(char *)"viewedge",
+     (getter)FEdge_viewedge_get,
+     (setter)FEdge_viewedge_set,
+     (char *)FEdge_viewedge_doc,
+     NULL},
+    {(char *)"is_smooth",
+     (getter)FEdge_is_smooth_get,
+     (setter)FEdge_is_smooth_set,
+     (char *)FEdge_is_smooth_doc,
+     NULL},
+    {(char *)"id", (getter)FEdge_id_get, (setter)FEdge_id_set, (char *)FEdge_id_doc, NULL},
+    {(char *)"nature",
+     (getter)FEdge_nature_get,
+     (setter)FEdge_nature_set,
+     (char *)FEdge_nature_doc,
+     NULL},
+    {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
 };
 
 /*-----------------------BPy_FEdge type definition ------------------------------*/
 
 PyTypeObject FEdge_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"FEdge",                        /* tp_name */
-	sizeof(BPy_FEdge),              /* tp_basicsize */
-	0,                              /* tp_itemsize */
-	0,                              /* tp_dealloc */
-	0,                              /* tp_print */
-	0,                              /* tp_getattr */
-	0,                              /* tp_setattr */
-	0,                              /* tp_reserved */
-	0,                              /* tp_repr */
-	0,                              /* tp_as_number */
-	&BPy_FEdge_as_sequence,         /* tp_as_sequence */
-	0,                              /* tp_as_mapping */
-	0,                              /* tp_hash  */
-	0,                              /* tp_call */
-	0,                              /* tp_str */
-	0,                              /* tp_getattro */
-	0,                              /* tp_setattro */
-	0,                              /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	FEdge_doc,                      /* tp_doc */
-	0,                              /* tp_traverse */
-	0,                              /* tp_clear */
-	0,                              /* tp_richcompare */
-	0,                              /* tp_weaklistoffset */
-	0,                              /* tp_iter */
-	0,                              /* tp_iternext */
-	0,                              /* tp_methods */
-	0,                              /* tp_members */
-	BPy_FEdge_getseters,            /* tp_getset */
-	&Interface1D_Type,              /* tp_base */
-	0,                              /* tp_dict */
-	0,                              /* tp_descr_get */
-	0,                              /* tp_descr_set */
-	0,                              /* tp_dictoffset */
-	(initproc)FEdge_init,           /* tp_init */
-	0,                              /* tp_alloc */
-	0,                              /* tp_new */
+    PyVarObject_HEAD_INIT(NULL, 0) "FEdge",   /* tp_name */
+    sizeof(BPy_FEdge),                        /* tp_basicsize */
+    0,                                        /* tp_itemsize */
+    0,                                        /* tp_dealloc */
+    0,                                        /* tp_print */
+    0,                                        /* tp_getattr */
+    0,                                        /* tp_setattr */
+    0,                                        /* tp_reserved */
+    0,                                        /* tp_repr */
+    0,                                        /* tp_as_number */
+    &BPy_FEdge_as_sequence,                   /* tp_as_sequence */
+    0,                                        /* tp_as_mapping */
+    0,                                        /* tp_hash  */
+    0,                                        /* tp_call */
+    0,                                        /* tp_str */
+    0,                                        /* tp_getattro */
+    0,                                        /* tp_setattro */
+    0,                                        /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+    FEdge_doc,                                /* tp_doc */
+    0,                                        /* tp_traverse */
+    0,                                        /* tp_clear */
+    0,                                        /* tp_richcompare */
+    0,                                        /* tp_weaklistoffset */
+    0,                                        /* tp_iter */
+    0,                                        /* tp_iternext */
+    0,                                        /* tp_methods */
+    0,                                        /* tp_members */
+    BPy_FEdge_getseters,                      /* tp_getset */
+    &Interface1D_Type,                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    (initproc)FEdge_init,                     /* tp_init */
+    0,                                        /* tp_alloc */
+    0,                                        /* tp_new */
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////