UI: Tweak Sequencer Sidebar panels
[blender.git] / source / blender / python / generic / idprop_py_api.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup pygen
19  */
20
21 #include <Python.h>
22
23 #include "MEM_guardedalloc.h"
24
25 #include "BLI_utildefines.h"
26
27 #include "idprop_py_api.h"
28
29 #include "BKE_idprop.h"
30
31 #define USE_STRING_COERCE
32
33 #ifdef USE_STRING_COERCE
34 #  include "py_capi_utils.h"
35 #endif
36
37 #include "python_utildefines.h"
38
39 extern bool pyrna_id_FromPyObject(PyObject *obj, ID **id);
40 extern PyObject *pyrna_id_CreatePyObject(ID *id);
41 extern bool pyrna_id_CheckPyObject(PyObject *obj);
42
43 /*********************** ID Property Main Wrapper Stuff ***************/
44
45 /* ----------------------------------------------------------------------------
46  * static conversion functions to avoid duplicate code, no type checking.
47  */
48
49 static PyObject *idprop_py_from_idp_string(const IDProperty *prop)
50 {
51   if (prop->subtype == IDP_STRING_SUB_BYTE) {
52     return PyBytes_FromStringAndSize(IDP_String(prop), prop->len);
53   }
54   else {
55 #ifdef USE_STRING_COERCE
56     return PyC_UnicodeFromByteAndSize(IDP_Array(prop), prop->len - 1);
57 #else
58     return PyUnicode_FromStringAndSize(IDP_String(prop), prop->len - 1);
59 #endif
60   }
61 }
62
63 static PyObject *idprop_py_from_idp_int(const IDProperty *prop)
64 {
65   return PyLong_FromLong((long)IDP_Int(prop));
66 }
67
68 static PyObject *idprop_py_from_idp_float(const IDProperty *prop)
69 {
70   return PyFloat_FromDouble((double)IDP_Float(prop));
71 }
72
73 static PyObject *idprop_py_from_idp_double(const IDProperty *prop)
74 {
75   return PyFloat_FromDouble(IDP_Double(prop));
76 }
77
78 static PyObject *idprop_py_from_idp_group(ID *id, IDProperty *prop, IDProperty *parent)
79 {
80   BPy_IDProperty *group = PyObject_New(BPy_IDProperty, &BPy_IDGroup_Type);
81   group->id = id;
82   group->prop = prop;
83   group->parent = parent; /* can be NULL */
84   return (PyObject *)group;
85 }
86
87 static PyObject *idprop_py_from_idp_id(IDProperty *prop)
88 {
89   return pyrna_id_CreatePyObject(prop->data.pointer);
90 }
91
92 static PyObject *idprop_py_from_idp_array(ID *id, IDProperty *prop)
93 {
94   BPy_IDProperty *array = PyObject_New(BPy_IDProperty, &BPy_IDArray_Type);
95   array->id = id;
96   array->prop = prop;
97   return (PyObject *)array;
98 }
99
100 static PyObject *idprop_py_from_idp_idparray(ID *id, IDProperty *prop)
101 {
102   PyObject *seq = PyList_New(prop->len);
103   IDProperty *array = IDP_IDPArray(prop);
104   int i;
105
106   if (!seq) {
107     PyErr_Format(
108         PyExc_RuntimeError, "%s: IDP_IDPARRAY: PyList_New(%d) failed", __func__, prop->len);
109     return NULL;
110   }
111
112   for (i = 0; i < prop->len; i++) {
113     PyObject *wrap = BPy_IDGroup_WrapData(id, array++, prop);
114
115     /* BPy_IDGroup_MapDataToPy sets the error */
116     if (UNLIKELY(wrap == NULL)) {
117       Py_DECREF(seq);
118       return NULL;
119     }
120
121     PyList_SET_ITEM(seq, i, wrap);
122   }
123
124   return seq;
125 }
126
127 /* -------------------------------------------------------------------------- */
128
129 /* use for both array and group */
130 static Py_hash_t BPy_IDGroup_hash(BPy_IDProperty *self)
131 {
132   return _Py_HashPointer(self->prop);
133 }
134
135 static PyObject *BPy_IDGroup_repr(BPy_IDProperty *self)
136 {
137   return PyUnicode_FromFormat("<bpy id prop: owner=\"%s\", name=\"%s\", address=%p>",
138                               self->id ? self->id->name : "<NONE>",
139                               self->prop->name,
140                               self->prop);
141 }
142
143 PyObject *BPy_IDGroup_WrapData(ID *id, IDProperty *prop, IDProperty *parent)
144 {
145   switch (prop->type) {
146     case IDP_STRING:
147       return idprop_py_from_idp_string(prop);
148     case IDP_INT:
149       return idprop_py_from_idp_int(prop);
150     case IDP_FLOAT:
151       return idprop_py_from_idp_float(prop);
152     case IDP_DOUBLE:
153       return idprop_py_from_idp_double(prop);
154     case IDP_GROUP:
155       return idprop_py_from_idp_group(id, prop, parent);
156     case IDP_ARRAY:
157       return idprop_py_from_idp_array(id, prop);
158     case IDP_IDPARRAY:
159       return idprop_py_from_idp_idparray(id, prop); /* this could be better a internal type */
160     case IDP_ID:
161       return idprop_py_from_idp_id(prop);
162     default:
163       Py_RETURN_NONE;
164   }
165 }
166
167 /* UNUSED, currently assignment overwrites into new properties, rather than setting in-place. */
168 #if 0
169 static int BPy_IDGroup_SetData(BPy_IDProperty *self, IDProperty *prop, PyObject *value)
170 {
171   switch (prop->type) {
172     case IDP_STRING: {
173       char *st;
174       if (!PyUnicode_Check(value)) {
175         PyErr_SetString(PyExc_TypeError, "expected a string!");
176         return -1;
177       }
178       /* NOTE: if this code is enabled, bytes support needs to be added */
179 #  ifdef USE_STRING_COERCE
180       {
181         int alloc_len;
182         PyObject *value_coerce = NULL;
183
184         st = (char *)PyC_UnicodeAsByte(value, &value_coerce);
185         alloc_len = strlen(st) + 1;
186
187         st = _PyUnicode_AsString(value);
188         IDP_ResizeArray(prop, alloc_len);
189         memcpy(IDP_Array(prop), st, alloc_len);
190         Py_XDECREF(value_coerce);
191       }
192 #  else
193       st = _PyUnicode_AsString(value);
194       IDP_ResizeArray(prop, strlen(st) + 1);
195       strcpy(IDP_Array(prop), st);
196 #  endif
197
198       return 0;
199     }
200
201     case IDP_INT: {
202       int ivalue = PyLong_AsSsize_t(value);
203       if (ivalue == -1 && PyErr_Occurred()) {
204         PyErr_SetString(PyExc_TypeError, "expected an int type");
205         return -1;
206       }
207       IDP_Int(prop) = ivalue;
208       break;
209     }
210     case IDP_FLOAT: {
211       float fvalue = (float)PyFloat_AsDouble(value);
212       if (fvalue == -1 && PyErr_Occurred()) {
213         PyErr_SetString(PyExc_TypeError, "expected a float");
214         return -1;
215       }
216       IDP_Float(self->prop) = fvalue;
217       break;
218     }
219     case IDP_DOUBLE: {
220       double dvalue = PyFloat_AsDouble(value);
221       if (dvalue == -1 && PyErr_Occurred()) {
222         PyErr_SetString(PyExc_TypeError, "expected a float");
223         return -1;
224       }
225       IDP_Double(self->prop) = dvalue;
226       break;
227     }
228     default:
229       PyErr_SetString(PyExc_AttributeError, "attempt to set read-only attribute!");
230       return -1;
231   }
232   return 0;
233 }
234 #endif
235
236 static PyObject *BPy_IDGroup_GetName(BPy_IDProperty *self, void *UNUSED(closure))
237 {
238   return PyUnicode_FromString(self->prop->name);
239 }
240
241 static int BPy_IDGroup_SetName(BPy_IDProperty *self, PyObject *value, void *UNUSED(closure))
242 {
243   const char *name;
244   Py_ssize_t name_size;
245
246   if (!PyUnicode_Check(value)) {
247     PyErr_SetString(PyExc_TypeError, "expected a string!");
248     return -1;
249   }
250
251   name = _PyUnicode_AsStringAndSize(value, &name_size);
252
253   if (name_size > MAX_IDPROP_NAME) {
254     PyErr_SetString(PyExc_TypeError, "string length cannot exceed 63 characters!");
255     return -1;
256   }
257
258   memcpy(self->prop->name, name, name_size);
259   return 0;
260 }
261
262 #if 0
263 static PyObject *BPy_IDGroup_GetType(BPy_IDProperty *self)
264 {
265   return PyLong_FromLong(self->prop->type);
266 }
267 #endif
268
269 static PyGetSetDef BPy_IDGroup_getseters[] = {
270     {(char *)"name",
271      (getter)BPy_IDGroup_GetName,
272      (setter)BPy_IDGroup_SetName,
273      (char *)"The name of this Group.",
274      NULL},
275     {NULL, NULL, NULL, NULL, NULL},
276 };
277
278 static Py_ssize_t BPy_IDGroup_Map_Len(BPy_IDProperty *self)
279 {
280   if (self->prop->type != IDP_GROUP) {
281     PyErr_SetString(PyExc_TypeError, "len() of unsized object");
282     return -1;
283   }
284
285   return self->prop->len;
286 }
287
288 static PyObject *BPy_IDGroup_Map_GetItem(BPy_IDProperty *self, PyObject *item)
289 {
290   IDProperty *idprop;
291   const char *name;
292
293   if (self->prop->type != IDP_GROUP) {
294     PyErr_SetString(PyExc_TypeError, "unsubscriptable object");
295     return NULL;
296   }
297
298   name = _PyUnicode_AsString(item);
299
300   if (name == NULL) {
301     PyErr_SetString(PyExc_TypeError, "only strings are allowed as keys of ID properties");
302     return NULL;
303   }
304
305   idprop = IDP_GetPropertyFromGroup(self->prop, name);
306
307   if (idprop == NULL) {
308     PyErr_SetString(PyExc_KeyError, "key not in subgroup dict");
309     return NULL;
310   }
311
312   return BPy_IDGroup_WrapData(self->id, idprop, self->prop);
313 }
314
315 /* returns NULL on success, error string on failure */
316 static char idp_sequence_type(PyObject *seq_fast)
317 {
318   PyObject **seq_fast_items = PySequence_Fast_ITEMS(seq_fast);
319   PyObject *item;
320   char type = IDP_INT;
321
322   Py_ssize_t i, len = PySequence_Fast_GET_SIZE(seq_fast);
323
324   for (i = 0; i < len; i++) {
325     item = seq_fast_items[i];
326     if (PyFloat_Check(item)) {
327       if (type == IDP_IDPARRAY) { /* mixed dict/int */
328         return -1;
329       }
330       type = IDP_DOUBLE;
331     }
332     else if (PyLong_Check(item)) {
333       if (type == IDP_IDPARRAY) { /* mixed dict/int */
334         return -1;
335       }
336     }
337     else if (PyMapping_Check(item)) {
338       if (i != 0 && (type != IDP_IDPARRAY)) { /* mixed dict/int */
339         return -1;
340       }
341       type = IDP_IDPARRAY;
342     }
343     else {
344       return -1;
345     }
346   }
347
348   return type;
349 }
350
351 static const char *idp_try_read_name(PyObject *name_obj)
352 {
353   const char *name = NULL;
354   if (name_obj) {
355     Py_ssize_t name_size;
356     name = _PyUnicode_AsStringAndSize(name_obj, &name_size);
357
358     if (name == NULL) {
359       PyErr_Format(PyExc_KeyError,
360                    "invalid id-property key, expected a string, not a %.200s",
361                    Py_TYPE(name_obj)->tp_name);
362       return NULL;
363     }
364
365     if (name_size > MAX_IDPROP_NAME) {
366       PyErr_SetString(PyExc_KeyError,
367                       "the length of IDProperty names is limited to 63 characters");
368       return NULL;
369     }
370   }
371   else {
372     name = "";
373   }
374   return name;
375 }
376
377 /* -------------------------------------------------------------------------- */
378
379 /**
380  * The 'idp_from_Py*' functions expect that the input type has been checked before
381  * and return NULL if the IDProperty can't be created.
382  */
383
384 static IDProperty *idp_from_PyFloat(const char *name, PyObject *ob)
385 {
386   IDPropertyTemplate val = {0};
387   val.d = PyFloat_AsDouble(ob);
388   return IDP_New(IDP_DOUBLE, &val, name);
389 }
390
391 static IDProperty *idp_from_PyLong(const char *name, PyObject *ob)
392 {
393   IDPropertyTemplate val = {0};
394   val.i = PyC_Long_AsI32(ob);
395   if (val.i == -1 && PyErr_Occurred()) {
396     return NULL;
397   }
398   return IDP_New(IDP_INT, &val, name);
399 }
400
401 static IDProperty *idp_from_PyUnicode(const char *name, PyObject *ob)
402 {
403   IDProperty *prop;
404   IDPropertyTemplate val = {0};
405 #ifdef USE_STRING_COERCE
406   Py_ssize_t value_size;
407   PyObject *value_coerce = NULL;
408   val.string.str = PyC_UnicodeAsByteAndSize(ob, &value_size, &value_coerce);
409   val.string.len = (int)value_size + 1;
410   val.string.subtype = IDP_STRING_SUB_UTF8;
411   prop = IDP_New(IDP_STRING, &val, name);
412   Py_XDECREF(value_coerce);
413 #else
414   val.str = _PyUnicode_AsString(ob);
415   prop = IDP_New(IDP_STRING, val, name);
416 #endif
417   return prop;
418 }
419
420 static IDProperty *idp_from_PyBytes(const char *name, PyObject *ob)
421 {
422   IDPropertyTemplate val = {0};
423   val.string.str = PyBytes_AS_STRING(ob);
424   val.string.len = PyBytes_GET_SIZE(ob);
425   val.string.subtype = IDP_STRING_SUB_BYTE;
426   return IDP_New(IDP_STRING, &val, name);
427 }
428
429 static int idp_array_type_from_formatstr_and_size(const char *typestr, Py_ssize_t itemsize)
430 {
431   char format = PyC_StructFmt_type_from_str(typestr);
432
433   if (PyC_StructFmt_type_is_float_any(format)) {
434     if (itemsize == 4) {
435       return IDP_FLOAT;
436     }
437     if (itemsize == 8) {
438       return IDP_DOUBLE;
439     }
440   }
441   if (PyC_StructFmt_type_is_int_any(format)) {
442     if (itemsize == 4) {
443       return IDP_INT;
444     }
445   }
446
447   return -1;
448 }
449
450 static const char *idp_format_from_array_type(int type)
451 {
452   if (type == IDP_INT) {
453     return "i";
454   }
455   if (type == IDP_FLOAT) {
456     return "f";
457   }
458   if (type == IDP_DOUBLE) {
459     return "d";
460   }
461   return NULL;
462 }
463
464 static IDProperty *idp_from_PySequence_Buffer(const char *name, Py_buffer *buffer)
465 {
466   IDProperty *prop;
467   IDPropertyTemplate val = {0};
468
469   int id_type = idp_array_type_from_formatstr_and_size(buffer->format, buffer->itemsize);
470   if (id_type == -1) {
471     /* should never happen as the type has been checked before */
472     return NULL;
473   }
474   else {
475     val.array.type = id_type;
476     val.array.len = buffer->len / buffer->itemsize;
477   }
478   prop = IDP_New(IDP_ARRAY, &val, name);
479   memcpy(IDP_Array(prop), buffer->buf, buffer->len);
480   return prop;
481 }
482
483 static IDProperty *idp_from_PySequence_Fast(const char *name, PyObject *ob)
484 {
485   IDProperty *prop;
486   IDPropertyTemplate val = {0};
487
488   PyObject **ob_seq_fast_items;
489   PyObject *item;
490   int i;
491
492   ob_seq_fast_items = PySequence_Fast_ITEMS(ob);
493
494   if ((val.array.type = idp_sequence_type(ob)) == (char)-1) {
495     PyErr_SetString(PyExc_TypeError,
496                     "only floats, ints and dicts are allowed in ID property arrays");
497     return NULL;
498   }
499
500   /* validate sequence and derive type.
501    * we assume IDP_INT unless we hit a float
502    * number; then we assume it's */
503
504   val.array.len = PySequence_Fast_GET_SIZE(ob);
505
506   switch (val.array.type) {
507     case IDP_DOUBLE: {
508       double *prop_data;
509       prop = IDP_New(IDP_ARRAY, &val, name);
510       prop_data = IDP_Array(prop);
511       for (i = 0; i < val.array.len; i++) {
512         item = ob_seq_fast_items[i];
513         if (((prop_data[i] = PyFloat_AsDouble(item)) == -1.0) && PyErr_Occurred()) {
514           return NULL;
515         }
516       }
517       break;
518     }
519     case IDP_INT: {
520       int *prop_data;
521       prop = IDP_New(IDP_ARRAY, &val, name);
522       prop_data = IDP_Array(prop);
523       for (i = 0; i < val.array.len; i++) {
524         item = ob_seq_fast_items[i];
525         if (((prop_data[i] = PyC_Long_AsI32(item)) == -1) && PyErr_Occurred()) {
526           return NULL;
527         }
528       }
529       break;
530     }
531     case IDP_IDPARRAY: {
532       prop = IDP_NewIDPArray(name);
533       for (i = 0; i < val.array.len; i++) {
534         item = ob_seq_fast_items[i];
535         if (BPy_IDProperty_Map_ValidateAndCreate(NULL, prop, item) == false) {
536           return NULL;
537         }
538       }
539       break;
540     }
541     default:
542       /* should never happen */
543       PyErr_SetString(PyExc_RuntimeError, "internal error with idp array.type");
544       return NULL;
545   }
546   return prop;
547 }
548
549 static IDProperty *idp_from_PySequence(const char *name, PyObject *ob)
550 {
551   Py_buffer buffer;
552   bool use_buffer = false;
553
554   if (PyObject_CheckBuffer(ob)) {
555     PyObject_GetBuffer(ob, &buffer, PyBUF_SIMPLE | PyBUF_FORMAT);
556     char format = PyC_StructFmt_type_from_str(buffer.format);
557     if (PyC_StructFmt_type_is_float_any(format) ||
558         (PyC_StructFmt_type_is_int_any(format) && buffer.itemsize == 4)) {
559       use_buffer = true;
560     }
561     else {
562       PyBuffer_Release(&buffer);
563     }
564   }
565
566   if (use_buffer) {
567     IDProperty *prop = idp_from_PySequence_Buffer(name, &buffer);
568     PyBuffer_Release(&buffer);
569     return prop;
570   }
571   else {
572     PyObject *ob_seq_fast = PySequence_Fast(ob, "py -> idprop");
573     if (ob_seq_fast != NULL) {
574       IDProperty *prop = idp_from_PySequence_Fast(name, ob_seq_fast);
575       Py_DECREF(ob_seq_fast);
576       return prop;
577     }
578     else {
579       return NULL;
580     }
581   }
582 }
583
584 static IDProperty *idp_from_PyMapping(const char *name, PyObject *ob)
585 {
586   IDProperty *prop;
587   IDPropertyTemplate val = {0};
588
589   PyObject *keys, *vals, *key, *pval;
590   int i, len;
591   /* yay! we get into recursive stuff now! */
592   keys = PyMapping_Keys(ob);
593   vals = PyMapping_Values(ob);
594
595   /* we allocate the group first; if we hit any invalid data,
596    * we can delete it easily enough.*/
597   prop = IDP_New(IDP_GROUP, &val, name);
598   len = PyMapping_Length(ob);
599   for (i = 0; i < len; i++) {
600     key = PySequence_GetItem(keys, i);
601     pval = PySequence_GetItem(vals, i);
602     if (BPy_IDProperty_Map_ValidateAndCreate(key, prop, pval) == false) {
603       IDP_FreeProperty(prop);
604       Py_XDECREF(keys);
605       Py_XDECREF(vals);
606       Py_XDECREF(key);
607       Py_XDECREF(pval);
608       /* error is already set */
609       return NULL;
610     }
611     Py_XDECREF(key);
612     Py_XDECREF(pval);
613   }
614   Py_XDECREF(keys);
615   Py_XDECREF(vals);
616   return prop;
617 }
618
619 static IDProperty *idp_from_DatablockPointer(const char *name, PyObject *ob)
620 {
621   IDPropertyTemplate val = {0};
622   pyrna_id_FromPyObject(ob, &val.id);
623   return IDP_New(IDP_ID, &val, name);
624 }
625
626 static IDProperty *idp_from_PyObject(PyObject *name_obj, PyObject *ob)
627 {
628   const char *name = idp_try_read_name(name_obj);
629   if (name == NULL) {
630     return NULL;
631   }
632
633   if (PyFloat_Check(ob)) {
634     return idp_from_PyFloat(name, ob);
635   }
636   else if (PyLong_Check(ob)) {
637     return idp_from_PyLong(name, ob);
638   }
639   else if (PyUnicode_Check(ob)) {
640     return idp_from_PyUnicode(name, ob);
641   }
642   else if (PyBytes_Check(ob)) {
643     return idp_from_PyBytes(name, ob);
644   }
645   else if (PySequence_Check(ob)) {
646     return idp_from_PySequence(name, ob);
647   }
648   else if (ob == Py_None || pyrna_id_CheckPyObject(ob)) {
649     return idp_from_DatablockPointer(name, ob);
650   }
651   else if (PyMapping_Check(ob)) {
652     return idp_from_PyMapping(name, ob);
653   }
654   else {
655     PyErr_Format(
656         PyExc_TypeError, "invalid id-property type %.200s not supported", Py_TYPE(ob)->tp_name);
657     return NULL;
658   }
659 }
660
661 /* -------------------------------------------------------------------------- */
662 /**
663  * \note group can be a pointer array or a group.
664  * assume we already checked key is a string.
665  *
666  * \return success.
667  */
668 bool BPy_IDProperty_Map_ValidateAndCreate(PyObject *name_obj, IDProperty *group, PyObject *ob)
669 {
670   IDProperty *prop = idp_from_PyObject(name_obj, ob);
671   if (prop == NULL) {
672     return false;
673   }
674
675   if (group->type == IDP_IDPARRAY) {
676     IDP_AppendArray(group, prop);
677     /* IDP_AppendArray does a shallow copy (memcpy), only free memory */
678     MEM_freeN(prop);
679   }
680   else {
681     IDProperty *prop_exist;
682
683     /* avoid freeing when types match in case they are referenced by the UI, see: T37073
684      * obviously this isn't a complete solution, but helps for common cases. */
685     prop_exist = IDP_GetPropertyFromGroup(group, prop->name);
686     if ((prop_exist != NULL) && (prop_exist->type == prop->type) &&
687         (prop_exist->subtype == prop->subtype)) {
688       /* Preserve prev/next links!!! See T42593. */
689       prop->prev = prop_exist->prev;
690       prop->next = prop_exist->next;
691
692       IDP_FreePropertyContent(prop_exist);
693       *prop_exist = *prop;
694       MEM_freeN(prop);
695     }
696     else {
697       IDP_ReplaceInGroup_ex(group, prop, prop_exist);
698     }
699   }
700
701   return true;
702 }
703
704 int BPy_Wrap_SetMapItem(IDProperty *prop, PyObject *key, PyObject *val)
705 {
706   if (prop->type != IDP_GROUP) {
707     PyErr_SetString(PyExc_TypeError, "unsubscriptable object");
708     return -1;
709   }
710
711   if (val == NULL) { /* del idprop[key] */
712     IDProperty *pkey;
713     const char *name = _PyUnicode_AsString(key);
714
715     if (name == NULL) {
716       PyErr_Format(PyExc_KeyError, "expected a string, not %.200s", Py_TYPE(key)->tp_name);
717       return -1;
718     }
719
720     pkey = IDP_GetPropertyFromGroup(prop, name);
721     if (pkey) {
722       IDP_FreeFromGroup(prop, pkey);
723       return 0;
724     }
725     else {
726       PyErr_SetString(PyExc_KeyError, "property not found in group");
727       return -1;
728     }
729   }
730   else {
731     bool ok;
732
733     ok = BPy_IDProperty_Map_ValidateAndCreate(key, prop, val);
734     if (ok == false) {
735       return -1;
736     }
737
738     return 0;
739   }
740 }
741
742 static int BPy_IDGroup_Map_SetItem(BPy_IDProperty *self, PyObject *key, PyObject *val)
743 {
744   return BPy_Wrap_SetMapItem(self->prop, key, val);
745 }
746
747 static PyObject *BPy_IDGroup_iter(BPy_IDProperty *self)
748 {
749   BPy_IDGroup_Iter *iter = PyObject_New(BPy_IDGroup_Iter, &BPy_IDGroup_Iter_Type);
750   iter->group = self;
751   iter->mode = IDPROP_ITER_KEYS;
752   iter->cur = self->prop->data.group.first;
753   Py_XINCREF(iter);
754   return (PyObject *)iter;
755 }
756
757 /* for simple, non nested types this is the same as BPy_IDGroup_WrapData */
758 static PyObject *BPy_IDGroup_MapDataToPy(IDProperty *prop)
759 {
760   switch (prop->type) {
761     case IDP_STRING:
762       return idprop_py_from_idp_string(prop);
763     case IDP_INT:
764       return idprop_py_from_idp_int(prop);
765     case IDP_FLOAT:
766       return idprop_py_from_idp_float(prop);
767     case IDP_DOUBLE:
768       return idprop_py_from_idp_double(prop);
769     case IDP_ID:
770       return idprop_py_from_idp_id(prop);
771     case IDP_ARRAY: {
772       PyObject *seq = PyList_New(prop->len);
773       int i;
774
775       if (!seq) {
776         PyErr_Format(
777             PyExc_RuntimeError, "%s: IDP_ARRAY: PyList_New(%d) failed", __func__, prop->len);
778         return NULL;
779       }
780
781       switch (prop->subtype) {
782         case IDP_FLOAT: {
783           const float *array = (float *)IDP_Array(prop);
784           for (i = 0; i < prop->len; i++) {
785             PyList_SET_ITEM(seq, i, PyFloat_FromDouble(array[i]));
786           }
787           break;
788         }
789         case IDP_DOUBLE: {
790           const double *array = (double *)IDP_Array(prop);
791           for (i = 0; i < prop->len; i++) {
792             PyList_SET_ITEM(seq, i, PyFloat_FromDouble(array[i]));
793           }
794           break;
795         }
796         case IDP_INT: {
797           const int *array = (int *)IDP_Array(prop);
798           for (i = 0; i < prop->len; i++) {
799             PyList_SET_ITEM(seq, i, PyLong_FromLong(array[i]));
800           }
801           break;
802         }
803         default:
804           PyErr_Format(
805               PyExc_RuntimeError, "%s: invalid/corrupt array type '%d'!", __func__, prop->subtype);
806           Py_DECREF(seq);
807           return NULL;
808       }
809
810       return seq;
811     }
812     case IDP_IDPARRAY: {
813       PyObject *seq = PyList_New(prop->len);
814       IDProperty *array = IDP_IDPArray(prop);
815       int i;
816
817       if (!seq) {
818         PyErr_Format(
819             PyExc_RuntimeError, "%s: IDP_IDPARRAY: PyList_New(%d) failed", __func__, prop->len);
820         return NULL;
821       }
822
823       for (i = 0; i < prop->len; i++) {
824         PyObject *wrap = BPy_IDGroup_MapDataToPy(array++);
825
826         /* BPy_IDGroup_MapDataToPy sets the error */
827         if (UNLIKELY(wrap == NULL)) {
828           Py_DECREF(seq);
829           return NULL;
830         }
831
832         PyList_SET_ITEM(seq, i, wrap);
833       }
834       return seq;
835     }
836     case IDP_GROUP: {
837       PyObject *dict = _PyDict_NewPresized(prop->len);
838       IDProperty *loop;
839
840       for (loop = prop->data.group.first; loop; loop = loop->next) {
841         PyObject *wrap = BPy_IDGroup_MapDataToPy(loop);
842
843         /* BPy_IDGroup_MapDataToPy sets the error */
844         if (UNLIKELY(wrap == NULL)) {
845           Py_DECREF(dict);
846           return NULL;
847         }
848
849         PyDict_SetItemString(dict, loop->name, wrap);
850         Py_DECREF(wrap);
851       }
852       return dict;
853     }
854   }
855
856   PyErr_Format(PyExc_RuntimeError,
857                "%s ERROR: '%s' property exists with a bad type code '%d'!",
858                __func__,
859                prop->name,
860                prop->type);
861   return NULL;
862 }
863
864 PyDoc_STRVAR(
865     BPy_IDGroup_pop_doc,
866     ".. method:: pop(key, default)\n"
867     "\n"
868     "   Remove an item from the group, returning a Python representation.\n"
869     "\n"
870     "   :raises KeyError: When the item doesn't exist.\n"
871     "\n"
872     "   :arg key: Name of item to remove.\n"
873     "   :type key: string\n"
874     "   :arg default: Value to return when key isn't found, otherwise raise an exception.\n"
875     "   :type default: Undefined\n");
876 static PyObject *BPy_IDGroup_pop(BPy_IDProperty *self, PyObject *args)
877 {
878   IDProperty *idprop;
879   PyObject *pyform;
880
881   char *key;
882   PyObject *def = NULL;
883
884   if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) {
885     return NULL;
886   }
887
888   idprop = IDP_GetPropertyFromGroup(self->prop, key);
889   if (idprop == NULL) {
890     if (def == NULL) {
891       PyErr_SetString(PyExc_KeyError, "item not in group");
892       return NULL;
893     }
894     return Py_INCREF_RET(def);
895   }
896
897   pyform = BPy_IDGroup_MapDataToPy(idprop);
898   if (pyform == NULL) {
899     /* ok something bad happened with the pyobject,
900      * so don't remove the prop from the group.  if pyform is
901      * NULL, then it already should have raised an exception.*/
902     return NULL;
903   }
904
905   IDP_RemoveFromGroup(self->prop, idprop);
906   return pyform;
907 }
908
909 PyDoc_STRVAR(
910     BPy_IDGroup_iter_items_doc,
911     ".. method:: iteritems()\n"
912     "\n"
913     "   Iterate through the items in the dict; behaves like dictionary method iteritems.\n");
914 static PyObject *BPy_IDGroup_iter_items(BPy_IDProperty *self)
915 {
916   BPy_IDGroup_Iter *iter = PyObject_New(BPy_IDGroup_Iter, &BPy_IDGroup_Iter_Type);
917   iter->group = self;
918   iter->mode = IDPROP_ITER_ITEMS;
919   iter->cur = self->prop->data.group.first;
920   Py_XINCREF(iter);
921   return (PyObject *)iter;
922 }
923
924 /* utility function */
925 static void BPy_IDGroup_CorrectListLen(IDProperty *prop, PyObject *seq, int len, const char *func)
926 {
927   int j;
928
929   printf("%s: ID Property Error found and corrected!\n", func);
930
931   /* fill rest of list with valid references to None */
932   for (j = len; j < prop->len; j++) {
933     PyList_SET_ITEM(seq, j, Py_INCREF_RET(Py_None));
934   }
935
936   /*set correct group length*/
937   prop->len = len;
938 }
939
940 PyObject *BPy_Wrap_GetKeys(IDProperty *prop)
941 {
942   PyObject *list = PyList_New(prop->len);
943   IDProperty *loop;
944   int i;
945
946   for (i = 0, loop = prop->data.group.first; loop && (i < prop->len); loop = loop->next, i++) {
947     PyList_SET_ITEM(list, i, PyUnicode_FromString(loop->name));
948   }
949
950   /* if the id prop is corrupt, count the remaining */
951   for (; loop; loop = loop->next, i++) {
952     /* pass */
953   }
954
955   if (i != prop->len) { /* if the loop didn't finish, we know the length is wrong */
956     BPy_IDGroup_CorrectListLen(prop, list, i, __func__);
957     Py_DECREF(list); /*free the list*/
958     /*call self again*/
959     return BPy_Wrap_GetKeys(prop);
960   }
961
962   return list;
963 }
964
965 PyObject *BPy_Wrap_GetValues(ID *id, IDProperty *prop)
966 {
967   PyObject *list = PyList_New(prop->len);
968   IDProperty *loop;
969   int i;
970
971   for (i = 0, loop = prop->data.group.first; loop; loop = loop->next, i++) {
972     PyList_SET_ITEM(list, i, BPy_IDGroup_WrapData(id, loop, prop));
973   }
974
975   if (i != prop->len) {
976     BPy_IDGroup_CorrectListLen(prop, list, i, __func__);
977     Py_DECREF(list); /*free the list*/
978     /*call self again*/
979     return BPy_Wrap_GetValues(id, prop);
980   }
981
982   return list;
983 }
984
985 PyObject *BPy_Wrap_GetItems(ID *id, IDProperty *prop)
986 {
987   PyObject *seq = PyList_New(prop->len);
988   IDProperty *loop;
989   int i;
990
991   for (i = 0, loop = prop->data.group.first; loop; loop = loop->next, i++) {
992     PyObject *item = PyTuple_New(2);
993     PyTuple_SET_ITEMS(
994         item, PyUnicode_FromString(loop->name), BPy_IDGroup_WrapData(id, loop, prop));
995     PyList_SET_ITEM(seq, i, item);
996   }
997
998   if (i != prop->len) {
999     BPy_IDGroup_CorrectListLen(prop, seq, i, __func__);
1000     Py_DECREF(seq); /*free the list*/
1001     /*call self again*/
1002     return BPy_Wrap_GetItems(id, prop);
1003   }
1004
1005   return seq;
1006 }
1007
1008 PyDoc_STRVAR(BPy_IDGroup_keys_doc,
1009              ".. method:: keys()\n"
1010              "\n"
1011              "   Return the keys associated with this group as a list of strings.\n");
1012 static PyObject *BPy_IDGroup_keys(BPy_IDProperty *self)
1013 {
1014   return BPy_Wrap_GetKeys(self->prop);
1015 }
1016
1017 PyDoc_STRVAR(BPy_IDGroup_values_doc,
1018              ".. method:: values()\n"
1019              "\n"
1020              "   Return the values associated with this group.\n");
1021 static PyObject *BPy_IDGroup_values(BPy_IDProperty *self)
1022 {
1023   return BPy_Wrap_GetValues(self->id, self->prop);
1024 }
1025
1026 PyDoc_STRVAR(BPy_IDGroup_items_doc,
1027              ".. method:: items()\n"
1028              "\n"
1029              "   Return the items associated with this group.\n");
1030 static PyObject *BPy_IDGroup_items(BPy_IDProperty *self)
1031 {
1032   return BPy_Wrap_GetItems(self->id, self->prop);
1033 }
1034
1035 static int BPy_IDGroup_Contains(BPy_IDProperty *self, PyObject *value)
1036 {
1037   const char *name = _PyUnicode_AsString(value);
1038
1039   if (!name) {
1040     PyErr_Format(PyExc_TypeError, "expected a string, not a %.200s", Py_TYPE(value)->tp_name);
1041     return -1;
1042   }
1043
1044   return IDP_GetPropertyFromGroup(self->prop, name) ? 1 : 0;
1045 }
1046
1047 PyDoc_STRVAR(BPy_IDGroup_update_doc,
1048              ".. method:: update(other)\n"
1049              "\n"
1050              "   Update key, values.\n"
1051              "\n"
1052              "   :arg other: Updates the values in the group with this.\n"
1053              "   :type other: :class:`IDPropertyGroup` or dict\n");
1054 static PyObject *BPy_IDGroup_update(BPy_IDProperty *self, PyObject *value)
1055 {
1056   PyObject *pkey, *pval;
1057   Py_ssize_t i = 0;
1058
1059   if (BPy_IDGroup_Check(value)) {
1060     BPy_IDProperty *other = (BPy_IDProperty *)value;
1061     if (UNLIKELY(self->prop == other->prop)) {
1062       Py_RETURN_NONE;
1063     }
1064
1065     /* XXX, possible one is inside the other */
1066     IDP_MergeGroup(self->prop, other->prop, true);
1067   }
1068   else if (PyDict_Check(value)) {
1069     while (PyDict_Next(value, &i, &pkey, &pval)) {
1070       BPy_IDGroup_Map_SetItem(self, pkey, pval);
1071       if (PyErr_Occurred()) {
1072         return NULL;
1073       }
1074     }
1075   }
1076   else {
1077     PyErr_Format(PyExc_TypeError,
1078                  "expected a dict or an IDPropertyGroup type, not a %.200s",
1079                  Py_TYPE(value)->tp_name);
1080     return NULL;
1081   }
1082
1083   Py_RETURN_NONE;
1084 }
1085
1086 PyDoc_STRVAR(BPy_IDGroup_to_dict_doc,
1087              ".. method:: to_dict()\n"
1088              "\n"
1089              "   Return a purely python version of the group.\n");
1090 static PyObject *BPy_IDGroup_to_dict(BPy_IDProperty *self)
1091 {
1092   return BPy_IDGroup_MapDataToPy(self->prop);
1093 }
1094
1095 PyDoc_STRVAR(BPy_IDGroup_clear_doc,
1096              ".. method:: clear()\n"
1097              "\n"
1098              "   Clear all members from this group.\n");
1099 static PyObject *BPy_IDGroup_clear(BPy_IDProperty *self)
1100 {
1101   IDP_ClearProperty(self->prop);
1102   Py_RETURN_NONE;
1103 }
1104
1105 PyDoc_STRVAR(BPy_IDGroup_get_doc,
1106              ".. method:: get(key, default=None)\n"
1107              "\n"
1108              "   Return the value for key, if it exists, else default.\n");
1109 static PyObject *BPy_IDGroup_get(BPy_IDProperty *self, PyObject *args)
1110 {
1111   IDProperty *idprop;
1112   const char *key;
1113   PyObject *def = Py_None;
1114
1115   if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) {
1116     return NULL;
1117   }
1118
1119   idprop = IDP_GetPropertyFromGroup(self->prop, key);
1120   if (idprop) {
1121     PyObject *pyobj = BPy_IDGroup_WrapData(self->id, idprop, self->prop);
1122     if (pyobj) {
1123       return pyobj;
1124     }
1125   }
1126
1127   Py_INCREF(def);
1128   return def;
1129 }
1130
1131 static struct PyMethodDef BPy_IDGroup_methods[] = {
1132     {"pop", (PyCFunction)BPy_IDGroup_pop, METH_VARARGS, BPy_IDGroup_pop_doc},
1133     {"iteritems", (PyCFunction)BPy_IDGroup_iter_items, METH_NOARGS, BPy_IDGroup_iter_items_doc},
1134     {"keys", (PyCFunction)BPy_IDGroup_keys, METH_NOARGS, BPy_IDGroup_keys_doc},
1135     {"values", (PyCFunction)BPy_IDGroup_values, METH_NOARGS, BPy_IDGroup_values_doc},
1136     {"items", (PyCFunction)BPy_IDGroup_items, METH_NOARGS, BPy_IDGroup_items_doc},
1137     {"update", (PyCFunction)BPy_IDGroup_update, METH_O, BPy_IDGroup_update_doc},
1138     {"get", (PyCFunction)BPy_IDGroup_get, METH_VARARGS, BPy_IDGroup_get_doc},
1139     {"to_dict", (PyCFunction)BPy_IDGroup_to_dict, METH_NOARGS, BPy_IDGroup_to_dict_doc},
1140     {"clear", (PyCFunction)BPy_IDGroup_clear, METH_NOARGS, BPy_IDGroup_clear_doc},
1141     {NULL, NULL, 0, NULL},
1142 };
1143
1144 static PySequenceMethods BPy_IDGroup_Seq = {
1145     (lenfunc)BPy_IDGroup_Map_Len, /* lenfunc sq_length */
1146     NULL,                         /* binaryfunc sq_concat */
1147     NULL,                         /* ssizeargfunc sq_repeat */
1148     NULL,
1149     /* ssizeargfunc sq_item */ /* TODO - setting this will allow PySequence_Check to return True */
1150     NULL,                      /* intintargfunc ***was_sq_slice*** */
1151     NULL,                      /* intobjargproc sq_ass_item */
1152     NULL,                      /* ssizeobjargproc ***was_sq_ass_slice*** */
1153     (objobjproc)BPy_IDGroup_Contains, /* objobjproc sq_contains */
1154     NULL,                             /* binaryfunc sq_inplace_concat */
1155     NULL,                             /* ssizeargfunc sq_inplace_repeat */
1156 };
1157
1158 static PyMappingMethods BPy_IDGroup_Mapping = {
1159     (lenfunc)BPy_IDGroup_Map_Len,           /*inquiry mp_length */
1160     (binaryfunc)BPy_IDGroup_Map_GetItem,    /*binaryfunc mp_subscript */
1161     (objobjargproc)BPy_IDGroup_Map_SetItem, /*objobjargproc mp_ass_subscript */
1162 };
1163
1164 PyTypeObject BPy_IDGroup_Type = {
1165     PyVarObject_HEAD_INIT(NULL, 0)
1166     /*  For printing, in format "<module>.<name>" */
1167     "IDPropertyGroup",      /* char *tp_name; */
1168     sizeof(BPy_IDProperty), /* int tp_basicsize; */
1169     0,                      /* tp_itemsize;  For allocation */
1170
1171     /* Methods to implement standard operations */
1172
1173     NULL,                       /* destructor tp_dealloc; */
1174     NULL,                       /* printfunc tp_print; */
1175     NULL,                       /* getattrfunc tp_getattr; */
1176     NULL,                       /* setattrfunc tp_setattr; */
1177     NULL,                       /* cmpfunc tp_compare; */
1178     (reprfunc)BPy_IDGroup_repr, /* reprfunc tp_repr; */
1179
1180     /* Method suites for standard classes */
1181
1182     NULL,                 /* PyNumberMethods *tp_as_number; */
1183     &BPy_IDGroup_Seq,     /* PySequenceMethods *tp_as_sequence; */
1184     &BPy_IDGroup_Mapping, /* PyMappingMethods *tp_as_mapping; */
1185
1186     /* More standard operations (here for binary compatibility) */
1187
1188     (hashfunc)BPy_IDGroup_hash, /* hashfunc tp_hash; */
1189     NULL,                       /* ternaryfunc tp_call; */
1190     NULL,                       /* reprfunc tp_str; */
1191     NULL,                       /* getattrofunc tp_getattro; */
1192     NULL,                       /* setattrofunc tp_setattro; */
1193
1194     /* Functions to access object as input/output buffer */
1195     NULL, /* PyBufferProcs *tp_as_buffer; */
1196
1197     /*** Flags to define presence of optional/expanded features ***/
1198     Py_TPFLAGS_DEFAULT, /* long tp_flags; */
1199
1200     NULL, /*  char *tp_doc;  Documentation string */
1201     /*** Assigned meaning in release 2.0 ***/
1202     /* call function for all accessible objects */
1203     NULL, /* traverseproc tp_traverse; */
1204
1205     /* delete references to contained objects */
1206     NULL, /* inquiry tp_clear; */
1207
1208     /***  Assigned meaning in release 2.1 ***/
1209     /*** rich comparisons ***/
1210     NULL, /* richcmpfunc tp_richcompare; */
1211
1212     /***  weak reference enabler ***/
1213     0, /* long tp_weaklistoffset; */
1214
1215     /*** Added in release 2.2 ***/
1216     /*   Iterators */
1217     (getiterfunc)BPy_IDGroup_iter, /* getiterfunc tp_iter; */
1218     NULL,                          /* iternextfunc tp_iternext; */
1219     /*** Attribute descriptor and subclassing stuff ***/
1220     BPy_IDGroup_methods,   /* struct PyMethodDef *tp_methods; */
1221     NULL,                  /* struct PyMemberDef *tp_members; */
1222     BPy_IDGroup_getseters, /* struct PyGetSetDef *tp_getset; */
1223 };
1224
1225 /********Array Wrapper********/
1226
1227 static PyTypeObject *idp_array_py_type(BPy_IDArray *self, bool *r_is_double)
1228 {
1229   switch (self->prop->subtype) {
1230     case IDP_FLOAT:
1231       *r_is_double = false;
1232       return &PyFloat_Type;
1233     case IDP_DOUBLE:
1234       *r_is_double = true;
1235       return &PyFloat_Type;
1236     case IDP_INT:
1237       *r_is_double = false;
1238       return &PyLong_Type;
1239     default:
1240       *r_is_double = false;
1241       return NULL;
1242   }
1243 }
1244
1245 static PyObject *BPy_IDArray_repr(BPy_IDArray *self)
1246 {
1247   return PyUnicode_FromFormat("<bpy id property array [%d]>", self->prop->len);
1248 }
1249
1250 PyDoc_STRVAR(BPy_IDArray_get_typecode_doc,
1251              "The type of the data in the array {'f': float, 'd': double, 'i': int}.");
1252 static PyObject *BPy_IDArray_get_typecode(BPy_IDArray *self)
1253 {
1254   switch (self->prop->subtype) {
1255     case IDP_FLOAT:
1256       return PyUnicode_FromString("f");
1257     case IDP_DOUBLE:
1258       return PyUnicode_FromString("d");
1259     case IDP_INT:
1260       return PyUnicode_FromString("i");
1261   }
1262
1263   PyErr_Format(
1264       PyExc_RuntimeError, "%s: invalid/corrupt array type '%d'!", __func__, self->prop->subtype);
1265
1266   return NULL;
1267 }
1268
1269 static PyGetSetDef BPy_IDArray_getseters[] = {
1270     /* matches pythons array.typecode */
1271     {(char *)"typecode",
1272      (getter)BPy_IDArray_get_typecode,
1273      (setter)NULL,
1274      BPy_IDArray_get_typecode_doc,
1275      NULL},
1276     {NULL, NULL, NULL, NULL, NULL},
1277 };
1278
1279 PyDoc_STRVAR(BPy_IDArray_to_list_doc,
1280              ".. method:: to_list()\n"
1281              "\n"
1282              "   Return the array as a list.\n");
1283 static PyObject *BPy_IDArray_to_list(BPy_IDArray *self)
1284 {
1285   return BPy_IDGroup_MapDataToPy(self->prop);
1286 }
1287
1288 static PyMethodDef BPy_IDArray_methods[] = {
1289     {"to_list", (PyCFunction)BPy_IDArray_to_list, METH_NOARGS, BPy_IDArray_to_list_doc},
1290     {NULL, NULL, 0, NULL},
1291 };
1292
1293 static int BPy_IDArray_Len(BPy_IDArray *self)
1294 {
1295   return self->prop->len;
1296 }
1297
1298 static PyObject *BPy_IDArray_GetItem(BPy_IDArray *self, int index)
1299 {
1300   if (index < 0 || index >= self->prop->len) {
1301     PyErr_SetString(PyExc_IndexError, "index out of range!");
1302     return NULL;
1303   }
1304
1305   switch (self->prop->subtype) {
1306     case IDP_FLOAT:
1307       return PyFloat_FromDouble(((float *)IDP_Array(self->prop))[index]);
1308     case IDP_DOUBLE:
1309       return PyFloat_FromDouble(((double *)IDP_Array(self->prop))[index]);
1310     case IDP_INT:
1311       return PyLong_FromLong((long)((int *)IDP_Array(self->prop))[index]);
1312   }
1313
1314   PyErr_Format(
1315       PyExc_RuntimeError, "%s: invalid/corrupt array type '%d'!", __func__, self->prop->subtype);
1316
1317   return NULL;
1318 }
1319
1320 static int BPy_IDArray_SetItem(BPy_IDArray *self, int index, PyObject *value)
1321 {
1322   if (index < 0 || index >= self->prop->len) {
1323     PyErr_SetString(PyExc_RuntimeError, "index out of range!");
1324     return -1;
1325   }
1326
1327   switch (self->prop->subtype) {
1328     case IDP_FLOAT: {
1329       const float f = (float)PyFloat_AsDouble(value);
1330       if (f == -1 && PyErr_Occurred()) {
1331         return -1;
1332       }
1333       ((float *)IDP_Array(self->prop))[index] = f;
1334       break;
1335     }
1336     case IDP_DOUBLE: {
1337       const double d = PyFloat_AsDouble(value);
1338       if (d == -1 && PyErr_Occurred()) {
1339         return -1;
1340       }
1341       ((double *)IDP_Array(self->prop))[index] = d;
1342       break;
1343     }
1344     case IDP_INT: {
1345       const int i = PyC_Long_AsI32(value);
1346       if (i == -1 && PyErr_Occurred()) {
1347         return -1;
1348       }
1349
1350       ((int *)IDP_Array(self->prop))[index] = i;
1351       break;
1352     }
1353   }
1354   return 0;
1355 }
1356
1357 static PySequenceMethods BPy_IDArray_Seq = {
1358     (lenfunc)BPy_IDArray_Len,             /* inquiry sq_length */
1359     NULL,                                 /* binaryfunc sq_concat */
1360     NULL,                                 /* intargfunc sq_repeat */
1361     (ssizeargfunc)BPy_IDArray_GetItem,    /* intargfunc sq_item */
1362     NULL,                                 /* intintargfunc sq_slice */
1363     (ssizeobjargproc)BPy_IDArray_SetItem, /* intobjargproc sq_ass_item */
1364     NULL,                                 /* intintobjargproc sq_ass_slice */
1365     NULL,                                 /* objobjproc sq_contains */
1366     /* Added in release 2.0 */
1367     NULL, /* binaryfunc sq_inplace_concat */
1368     NULL, /* intargfunc sq_inplace_repeat */
1369 };
1370
1371 /* sequence slice (get): idparr[a:b] */
1372 static PyObject *BPy_IDArray_slice(BPy_IDArray *self, int begin, int end)
1373 {
1374   IDProperty *prop = self->prop;
1375   PyObject *tuple;
1376   int count;
1377
1378   CLAMP(begin, 0, prop->len);
1379   if (end < 0) {
1380     end = prop->len + end + 1;
1381   }
1382   CLAMP(end, 0, prop->len);
1383   begin = MIN2(begin, end);
1384
1385   tuple = PyTuple_New(end - begin);
1386
1387   switch (prop->subtype) {
1388     case IDP_FLOAT: {
1389       const float *array = (float *)IDP_Array(prop);
1390       for (count = begin; count < end; count++) {
1391         PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(array[count]));
1392       }
1393       break;
1394     }
1395     case IDP_DOUBLE: {
1396       const double *array = (double *)IDP_Array(prop);
1397       for (count = begin; count < end; count++) {
1398         PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(array[count]));
1399       }
1400       break;
1401     }
1402     case IDP_INT: {
1403       const int *array = (int *)IDP_Array(prop);
1404       for (count = begin; count < end; count++) {
1405         PyTuple_SET_ITEM(tuple, count - begin, PyLong_FromLong(array[count]));
1406       }
1407       break;
1408     }
1409   }
1410
1411   return tuple;
1412 }
1413 /* sequence slice (set): idparr[a:b] = value */
1414 static int BPy_IDArray_ass_slice(BPy_IDArray *self, int begin, int end, PyObject *seq)
1415 {
1416   IDProperty *prop = self->prop;
1417   bool is_double;
1418   const PyTypeObject *py_type = idp_array_py_type(self, &is_double);
1419   const size_t elem_size = is_double ? sizeof(double) : sizeof(float);
1420   size_t alloc_len;
1421   size_t size;
1422   void *vec;
1423
1424   CLAMP(begin, 0, prop->len);
1425   CLAMP(end, 0, prop->len);
1426   begin = MIN2(begin, end);
1427
1428   size = (end - begin);
1429   alloc_len = size * elem_size;
1430
1431   vec = MEM_mallocN(alloc_len,
1432                     "array assignment"); /* NOTE: we count on int/float being the same size here */
1433   if (PyC_AsArray(vec, seq, size, py_type, is_double, "slice assignment: ") == -1) {
1434     MEM_freeN(vec);
1435     return -1;
1436   }
1437
1438   memcpy((void *)(((char *)IDP_Array(prop)) + (begin * elem_size)), vec, alloc_len);
1439
1440   MEM_freeN(vec);
1441   return 0;
1442 }
1443
1444 static PyObject *BPy_IDArray_subscript(BPy_IDArray *self, PyObject *item)
1445 {
1446   if (PyIndex_Check(item)) {
1447     Py_ssize_t i;
1448     i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1449     if (i == -1 && PyErr_Occurred()) {
1450       return NULL;
1451     }
1452     if (i < 0) {
1453       i += self->prop->len;
1454     }
1455     return BPy_IDArray_GetItem(self, i);
1456   }
1457   else if (PySlice_Check(item)) {
1458     Py_ssize_t start, stop, step, slicelength;
1459
1460     if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0) {
1461       return NULL;
1462     }
1463
1464     if (slicelength <= 0) {
1465       return PyTuple_New(0);
1466     }
1467     else if (step == 1) {
1468       return BPy_IDArray_slice(self, start, stop);
1469     }
1470     else {
1471       PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
1472       return NULL;
1473     }
1474   }
1475   else {
1476     PyErr_Format(PyExc_TypeError,
1477                  "vector indices must be integers, not %.200s",
1478                  __func__,
1479                  Py_TYPE(item)->tp_name);
1480     return NULL;
1481   }
1482 }
1483
1484 static int BPy_IDArray_ass_subscript(BPy_IDArray *self, PyObject *item, PyObject *value)
1485 {
1486   if (PyIndex_Check(item)) {
1487     Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1488     if (i == -1 && PyErr_Occurred()) {
1489       return -1;
1490     }
1491     if (i < 0) {
1492       i += self->prop->len;
1493     }
1494     return BPy_IDArray_SetItem(self, i, value);
1495   }
1496   else if (PySlice_Check(item)) {
1497     Py_ssize_t start, stop, step, slicelength;
1498
1499     if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0) {
1500       return -1;
1501     }
1502
1503     if (step == 1) {
1504       return BPy_IDArray_ass_slice(self, start, stop, value);
1505     }
1506     else {
1507       PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
1508       return -1;
1509     }
1510   }
1511   else {
1512     PyErr_Format(
1513         PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
1514     return -1;
1515   }
1516 }
1517
1518 static PyMappingMethods BPy_IDArray_AsMapping = {
1519     (lenfunc)BPy_IDArray_Len,
1520     (binaryfunc)BPy_IDArray_subscript,
1521     (objobjargproc)BPy_IDArray_ass_subscript,
1522 };
1523
1524 static int itemsize_by_idarray_type(int array_type)
1525 {
1526   if (array_type == IDP_INT) {
1527     return sizeof(int);
1528   }
1529   if (array_type == IDP_FLOAT) {
1530     return sizeof(float);
1531   }
1532   if (array_type == IDP_DOUBLE) {
1533     return sizeof(double);
1534   }
1535   return -1; /* should never happen */
1536 }
1537
1538 static int BPy_IDArray_getbuffer(BPy_IDArray *self, Py_buffer *view, int flags)
1539 {
1540   IDProperty *prop = self->prop;
1541   int itemsize = itemsize_by_idarray_type(prop->subtype);
1542   int length = itemsize * prop->len;
1543
1544   if (PyBuffer_FillInfo(view, (PyObject *)self, IDP_Array(prop), length, false, flags) == -1) {
1545     return -1;
1546   }
1547
1548   view->itemsize = itemsize;
1549   view->format = (char *)idp_format_from_array_type(prop->subtype);
1550
1551   Py_ssize_t *shape = MEM_mallocN(sizeof(Py_ssize_t), __func__);
1552   shape[0] = prop->len;
1553   view->shape = shape;
1554
1555   return 0;
1556 }
1557
1558 static void BPy_IDArray_releasebuffer(BPy_IDArray *UNUSED(self), Py_buffer *view)
1559 {
1560   MEM_freeN(view->shape);
1561 }
1562
1563 static PyBufferProcs BPy_IDArray_Buffer = {
1564     (getbufferproc)BPy_IDArray_getbuffer,
1565     (releasebufferproc)BPy_IDArray_releasebuffer,
1566 };
1567
1568 PyTypeObject BPy_IDArray_Type = {
1569     PyVarObject_HEAD_INIT(NULL, 0)
1570     /*  For printing, in format "<module>.<name>" */
1571     "IDPropertyArray",   /* char *tp_name; */
1572     sizeof(BPy_IDArray), /* int tp_basicsize; */
1573     0,                   /* tp_itemsize;  For allocation */
1574
1575     /* Methods to implement standard operations */
1576
1577     NULL,                       /* destructor tp_dealloc; */
1578     NULL,                       /* printfunc tp_print; */
1579     NULL,                       /* getattrfunc tp_getattr; */
1580     NULL,                       /* setattrfunc tp_setattr; */
1581     NULL,                       /* cmpfunc tp_compare; */
1582     (reprfunc)BPy_IDArray_repr, /* reprfunc tp_repr; */
1583
1584     /* Method suites for standard classes */
1585
1586     NULL,                   /* PyNumberMethods *tp_as_number; */
1587     &BPy_IDArray_Seq,       /* PySequenceMethods *tp_as_sequence; */
1588     &BPy_IDArray_AsMapping, /* PyMappingMethods *tp_as_mapping; */
1589
1590     /* More standard operations (here for binary compatibility) */
1591
1592     NULL, /* hashfunc tp_hash; */
1593     NULL, /* ternaryfunc tp_call; */
1594     NULL, /* reprfunc tp_str; */
1595     NULL, /* getattrofunc tp_getattro; */
1596     NULL, /* setattrofunc tp_setattro; */
1597
1598     /* Functions to access object as input/output buffer */
1599     &BPy_IDArray_Buffer, /* PyBufferProcs *tp_as_buffer; */
1600
1601     /*** Flags to define presence of optional/expanded features ***/
1602     Py_TPFLAGS_DEFAULT, /* long tp_flags; */
1603
1604     NULL, /*  char *tp_doc;  Documentation string */
1605     /*** Assigned meaning in release 2.0 ***/
1606     /* call function for all accessible objects */
1607     NULL, /* traverseproc tp_traverse; */
1608
1609     /* delete references to contained objects */
1610     NULL, /* inquiry tp_clear; */
1611
1612     /***  Assigned meaning in release 2.1 ***/
1613     /*** rich comparisons ***/
1614     NULL, /* richcmpfunc tp_richcompare; */
1615
1616     /***  weak reference enabler ***/
1617     0, /* long tp_weaklistoffset; */
1618
1619     /*** Added in release 2.2 ***/
1620     /*   Iterators */
1621     NULL, /* getiterfunc tp_iter; */
1622     NULL, /* iternextfunc tp_iternext; */
1623
1624     /*** Attribute descriptor and subclassing stuff ***/
1625     BPy_IDArray_methods,   /* struct PyMethodDef *tp_methods; */
1626     NULL,                  /* struct PyMemberDef *tp_members; */
1627     BPy_IDArray_getseters, /* struct PyGetSetDef *tp_getset; */
1628     NULL,                  /* struct _typeobject *tp_base; */
1629     NULL,                  /* PyObject *tp_dict; */
1630     NULL,                  /* descrgetfunc tp_descr_get; */
1631     NULL,                  /* descrsetfunc tp_descr_set; */
1632     0,                     /* long tp_dictoffset; */
1633     NULL,                  /* initproc tp_init; */
1634     NULL,                  /* allocfunc tp_alloc; */
1635     NULL,                  /* newfunc tp_new; */
1636     /*  Low-level free-memory routine */
1637     NULL, /* freefunc tp_free;  */
1638     /* For PyObject_IS_GC */
1639     NULL, /* inquiry tp_is_gc;  */
1640     NULL, /* PyObject *tp_bases; */
1641     /* method resolution order */
1642     NULL, /* PyObject *tp_mro;  */
1643     NULL, /* PyObject *tp_cache; */
1644     NULL, /* PyObject *tp_subclasses; */
1645     NULL, /* PyObject *tp_weaklist; */
1646     NULL,
1647 };
1648
1649 /*********** ID Property Group iterator ********/
1650
1651 static PyObject *IDGroup_Iter_repr(BPy_IDGroup_Iter *self)
1652 {
1653   return PyUnicode_FromFormat("(ID Property Group Iter \"%s\")", self->group->prop->name);
1654 }
1655
1656 static PyObject *BPy_Group_Iter_Next(BPy_IDGroup_Iter *self)
1657 {
1658
1659   if (self->cur) {
1660     PyObject *ret;
1661     IDProperty *cur;
1662
1663     cur = self->cur;
1664     self->cur = self->cur->next;
1665
1666     if (self->mode == IDPROP_ITER_ITEMS) {
1667       ret = PyTuple_New(2);
1668       PyTuple_SET_ITEMS(ret,
1669                         PyUnicode_FromString(cur->name),
1670                         BPy_IDGroup_WrapData(self->group->id, cur, self->group->prop));
1671       return ret;
1672     }
1673     else {
1674       return PyUnicode_FromString(cur->name);
1675     }
1676   }
1677   else {
1678     PyErr_SetNone(PyExc_StopIteration);
1679     return NULL;
1680   }
1681 }
1682
1683 PyTypeObject BPy_IDGroup_Iter_Type = {
1684     PyVarObject_HEAD_INIT(NULL, 0)
1685     /*  For printing, in format "<module>.<name>" */
1686     "IDPropertyGroupIter",    /* char *tp_name; */
1687     sizeof(BPy_IDGroup_Iter), /* int tp_basicsize; */
1688     0,                        /* tp_itemsize;  For allocation */
1689
1690     /* Methods to implement standard operations */
1691
1692     NULL,                        /* destructor tp_dealloc; */
1693     NULL,                        /* printfunc tp_print; */
1694     NULL,                        /* getattrfunc tp_getattr; */
1695     NULL,                        /* setattrfunc tp_setattr; */
1696     NULL,                        /* cmpfunc tp_compare; */
1697     (reprfunc)IDGroup_Iter_repr, /* reprfunc tp_repr; */
1698
1699     /* Method suites for standard classes */
1700
1701     NULL, /* PyNumberMethods *tp_as_number; */
1702     NULL, /* PySequenceMethods *tp_as_sequence; */
1703     NULL, /* PyMappingMethods *tp_as_mapping; */
1704
1705     /* More standard operations (here for binary compatibility) */
1706
1707     NULL, /* hashfunc tp_hash; */
1708     NULL, /* ternaryfunc tp_call; */
1709     NULL, /* reprfunc tp_str; */
1710     NULL, /* getattrofunc tp_getattro; */
1711     NULL, /* setattrofunc tp_setattro; */
1712
1713     /* Functions to access object as input/output buffer */
1714     NULL, /* PyBufferProcs *tp_as_buffer; */
1715
1716     /*** Flags to define presence of optional/expanded features ***/
1717     Py_TPFLAGS_DEFAULT, /* long tp_flags; */
1718
1719     NULL, /*  char *tp_doc;  Documentation string */
1720     /*** Assigned meaning in release 2.0 ***/
1721     /* call function for all accessible objects */
1722     NULL, /* traverseproc tp_traverse; */
1723
1724     /* delete references to contained objects */
1725     NULL, /* inquiry tp_clear; */
1726
1727     /***  Assigned meaning in release 2.1 ***/
1728     /*** rich comparisons ***/
1729     NULL, /* richcmpfunc tp_richcompare; */
1730
1731     /***  weak reference enabler ***/
1732     0, /* long tp_weaklistoffset; */
1733
1734     /*** Added in release 2.2 ***/
1735     /*   Iterators */
1736     PyObject_SelfIter,                 /* getiterfunc tp_iter; */
1737     (iternextfunc)BPy_Group_Iter_Next, /* iternextfunc tp_iternext; */
1738 };
1739
1740 void IDProp_Init_Types(void)
1741 {
1742   PyType_Ready(&BPy_IDGroup_Type);
1743   PyType_Ready(&BPy_IDGroup_Iter_Type);
1744   PyType_Ready(&BPy_IDArray_Type);
1745 }
1746
1747 /*----------------------------MODULE INIT-------------------------*/
1748
1749 /* --- */
1750
1751 static struct PyModuleDef IDProp_types_module_def = {
1752     PyModuleDef_HEAD_INIT,
1753     "idprop.types", /* m_name */
1754     NULL,           /* m_doc */
1755     0,              /* m_size */
1756     NULL,           /* m_methods */
1757     NULL,           /* m_reload */
1758     NULL,           /* m_traverse */
1759     NULL,           /* m_clear */
1760     NULL,           /* m_free */
1761 };
1762
1763 static PyObject *BPyInit_idprop_types(void)
1764 {
1765   PyObject *submodule;
1766
1767   submodule = PyModule_Create(&IDProp_types_module_def);
1768
1769   IDProp_Init_Types();
1770
1771 #define MODULE_TYPE_ADD(s, t) \
1772   PyModule_AddObject(s, t.tp_name, (PyObject *)&t); \
1773   Py_INCREF((PyObject *)&t)
1774
1775   /* bmesh_py_types.c */
1776   MODULE_TYPE_ADD(submodule, BPy_IDGroup_Type);
1777   MODULE_TYPE_ADD(submodule, BPy_IDGroup_Iter_Type);
1778   MODULE_TYPE_ADD(submodule, BPy_IDArray_Type);
1779
1780 #undef MODULE_TYPE_ADD
1781
1782   return submodule;
1783 }
1784
1785 /* --- */
1786
1787 static PyMethodDef IDProp_methods[] = {
1788     {NULL, NULL, 0, NULL},
1789 };
1790
1791 PyDoc_STRVAR(IDProp_module_doc,
1792              "This module provides access id property types (currently mainly for docs).");
1793 static struct PyModuleDef IDProp_module_def = {
1794     PyModuleDef_HEAD_INIT,
1795     "idprop",          /* m_name */
1796     IDProp_module_doc, /* m_doc */
1797     0,                 /* m_size */
1798     IDProp_methods,    /* m_methods */
1799     NULL,              /* m_reload */
1800     NULL,              /* m_traverse */
1801     NULL,              /* m_clear */
1802     NULL,              /* m_free */
1803 };
1804
1805 PyObject *BPyInit_idprop(void)
1806 {
1807   PyObject *mod;
1808   PyObject *submodule;
1809   PyObject *sys_modules = PyImport_GetModuleDict();
1810
1811   mod = PyModule_Create(&IDProp_module_def);
1812
1813   /* idprop.types */
1814   PyModule_AddObject(mod, "types", (submodule = BPyInit_idprop_types()));
1815   PyDict_SetItem(sys_modules, PyModule_GetNameObject(submodule), submodule);
1816
1817   return mod;
1818 }