*
* This file defines the types for 'BMesh.select_history'
* sequence and iterator.
+ *
+ * select_history is very loosely based on pytons set() type,
+ * since items can only exist once. however they do have an order.
*/
#include <Python.h>
Py_RETURN_NONE;
}
+PyDoc_STRVAR(bpy_bmeditselseq_add_doc,
+".. method:: add(element)\n"
+"\n"
+" Add an element to the selection history (no action taken if its already added).\n"
+);
+static PyObject *bpy_bmeditselseq_add(BPy_BMEditSelSeq *self, BPy_BMElem *value)
+{
+ BPY_BM_CHECK_OBJ(self);
+
+ if ((BPy_BMVert_Check(value) ||
+ BPy_BMEdge_Check(value) ||
+ BPy_BMFace_Check(value)) == FALSE)
+ {
+ PyErr_Format(PyExc_TypeError,
+ "Expected a BMVert/BMedge/BMFace not a %.200s", Py_TYPE(value)->tp_name);
+ return NULL;
+ }
+
+ BPY_BM_CHECK_OBJ(value);
+
+ if (self->bm != value->bm) {
+ PyErr_SetString(PyExc_ValueError,
+ "Element is not from this mesh");
+ return NULL;
+ }
+
+ BM_select_history_store(self->bm, value->ele)
+
+ Py_RETURN_NONE;
+}
+
PyDoc_STRVAR(bpy_bmeditselseq_remove_doc,
".. method:: remove(element)\n"
"\n"
static struct PyMethodDef bpy_bmeditselseq_methods[] = {
{"validate", (PyCFunction)bpy_bmeditselseq_validate, METH_NOARGS, bpy_bmeditselseq_validate_doc},
{"clear", (PyCFunction)bpy_bmeditselseq_clear, METH_NOARGS, bpy_bmeditselseq_clear_doc},
+
+ {"add", (PyCFunction)bpy_bmeditselseq_add, METH_O, bpy_bmeditselseq_add_doc},
{"remove", (PyCFunction)bpy_bmeditselseq_remove, METH_O, bpy_bmeditselseq_remove_doc},
{NULL, NULL, 0, NULL}
};
PyType_Ready(&BPy_BMEditSelSeq_Type);
PyType_Ready(&BPy_BMEditSelIter_Type);
}
+
+
+/* utility function */
+
+/**
+ * \note doesnt actually check selection.
+ */
+int BPy_BMEditSel_Assign(BPy_BMesh *self, PyObject *value)
+{
+ BMesh *bm;
+ Py_ssize_t value_len;
+ Py_ssize_t i;
+ BMElem **value_array = NULL;
+
+ BPY_BM_CHECK_INT(self);
+
+ bm = self->bm;
+
+ value_array = BPy_BMElem_PySeq_As_Array(&bm, value, 0, PY_SSIZE_T_MAX,
+ &value_len, BM_VERT | BM_EDGE | BM_FACE,
+ TRUE, TRUE, "BMesh.select_history = value");
+
+ if (value_array == NULL) {
+ return -1;
+ }
+
+ BM_select_history_clear(bm);
+
+ for (i = 0; i < value_len; i++) {
+ BM_select_history_store_notest(bm, value_array[i]);
+ }
+
+ PyMem_FREE(value_array);
+ return 0;
+}
return BPy_BMEditSel_CreatePyObject(self->bm);
}
-static int bpy_bmesh_select_history_set(BPy_BMesh *self, PyObject *UNUSED(value))
+static int bpy_bmesh_select_history_set(BPy_BMesh *self, PyObject *value)
{
BPY_BM_CHECK_INT(self);
- PyErr_SetString(PyExc_NotImplementedError, "not yet functional");
- return -1;
+ return BPy_BMEditSel_Assign(self, value);
}
/* Vert
Py_ssize_t vert_seq_len; /* always 2 */
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 2, 2,
- &vert_seq_len, &BPy_BMVert_Type,
+ &vert_seq_len, BM_VERT,
TRUE, TRUE, "BMVert.copy_from_vert_interp(...)");
if (vert_array == NULL) {
}
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 2, 2,
- &vert_seq_len, &BPy_BMVert_Type,
+ &vert_seq_len, BM_VERT,
TRUE, TRUE, "edges.new(...)");
if (vert_array == NULL) {
}
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 3, PY_SSIZE_T_MAX,
- &vert_seq_len, &BPy_BMVert_Type,
+ &vert_seq_len, BM_VERT,
TRUE, TRUE, "faces.new(...)");
if (vert_array == NULL) {
PyObject *ret = NULL;
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 2, 2,
- &vert_seq_len, &BPy_BMVert_Type,
+ &vert_seq_len, BM_VERT,
TRUE, TRUE, "edges.get(...)");
if (vert_array == NULL) {
PyObject *ret = NULL;
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 1, PY_SSIZE_T_MAX,
- &vert_seq_len, &BPy_BMVert_Type,
+ &vert_seq_len, BM_VERT,
TRUE, TRUE, "faces.get(...)");
if (vert_array == NULL) {
* The 'bm_r' value is assigned when empty, and used when set.
*/
void *BPy_BMElem_PySeq_As_Array(BMesh **r_bm, PyObject *seq, Py_ssize_t min, Py_ssize_t max, Py_ssize_t *r_size,
- PyTypeObject *type,
+ const char htype,
const char do_unique_check, const char do_bm_check,
const char *error_prefix)
{
for (i = 0; i < seq_len; i++) {
item = (BPy_BMElem *)PySequence_Fast_GET_ITEM(seq_fast, i);
- if (Py_TYPE(item) != type) {
+ if (!BPy_BMElem_CheckHType(Py_TYPE(item), htype)) {
PyErr_Format(PyExc_TypeError,
- "%s: expected '%.200s', not '%.200s'",
- error_prefix, type->tp_name, Py_TYPE(item)->tp_name);
+ "%s: expected %.200s, not '%.200s'",
+ error_prefix, BPy_BMElem_StringFromHType(htype), Py_TYPE(item)->tp_name);
goto err_cleanup;
}
else if (!BPY_BM_IS_VALID(item)) {
PyErr_Format(PyExc_TypeError,
"%s: %d %s has been removed",
- error_prefix, i, type->tp_name);
+ error_prefix, i, Py_TYPE(item)->tp_name);
goto err_cleanup;
}
/* trick so we can ensure all items have the same mesh,
else if (do_bm_check && (bm && bm != item->bm)) {
PyErr_Format(PyExc_ValueError,
"%s: %d %s is from another mesh",
- error_prefix, i, type->tp_name);
+ error_prefix, i, BPy_BMElem_StringFromHType(htype));
goto err_cleanup;
}
if (ok == FALSE) {
PyErr_Format(PyExc_ValueError,
- "%s: found the same %s used multiple times",
- error_prefix, type->tp_name);
+ "%s: found the same %.200s used multiple times",
+ error_prefix, BPy_BMElem_StringFromHType(htype));
goto err_cleanup;
}
}
return ret;
}
+
+int BPy_BMElem_CheckHType(PyTypeObject *type, const char htype)
+{
+ return (((htype & BM_VERT) && (type == &BPy_BMVert_Type)) ||
+ ((htype & BM_EDGE) && (type == &BPy_BMEdge_Type)) ||
+ ((htype & BM_FACE) && (type == &BPy_BMFace_Type)) ||
+ ((htype & BM_LOOP) && (type == &BPy_BMLoop_Type)));
+}
+
+/**
+ * Use for error strings only, not thread safe,
+ *
+ * \return a sting like '(BMVert/BMEdge/BMFace/BMLoop)'
+ */
+char *BPy_BMElem_StringFromHType(const char htype)
+{
+ /* zero to ensure string is always NULL terminated */
+ static char ret[32];
+ char *ret_ptr = ret;
+ if (htype & BM_VERT) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMVert_Type.tp_name);
+ if (htype & BM_EDGE) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMEdge_Type.tp_name);
+ if (htype & BM_FACE) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMFace_Type.tp_name);
+ if (htype & BM_LOOP) ret_ptr += sprintf(ret_ptr, "/%s", BPy_BMLoop_Type.tp_name);
+ ret[0] = '(';
+ *ret_ptr = ')';
+ return ret;
+}