static void check_attach(void)
{
xorn_revision_t rev;
xorn_object_t N, a, b;
struct xornsch_net net_data;
struct xornsch_text text_data;
assert(rev = xorn_new_revision(NULL));
memset(&net_data, 0, sizeof net_data);
assert(N = xornsch_add_net(rev, &net_data));
memset(&text_data, 0, sizeof text_data);
assert(a = xornsch_add_text(rev, &text_data));
assert(b = xornsch_add_text(rev, &text_data));
assert_object_location(rev, N, _, 0);
assert_object_location(rev, a, _, 1);
assert_object_location(rev, b, _, 2);
assert(xorn_relocate_object(rev, a, N, _) == 0);
assert_object_location(rev, N, _, 0);
assert_object_location(rev, a, N, 0);
assert_object_location(rev, b, _, 1);
assert(xorn_relocate_object(rev, b, N, _) == 0);
assert_object_location(rev, N, _, 0);
assert_object_location(rev, a, N, 0);
assert_object_location(rev, b, N, 1);
assert(xorn_relocate_object(rev, b, N, a) == 0);
assert_object_location(rev, N, _, 0);
assert_object_location(rev, a, N, 1);
assert_object_location(rev, b, N, 0);
assert(xorn_relocate_object(rev, a, _, N) == 0);
assert_object_location(rev, N, _, 1);
assert_object_location(rev, a, _, 0);
assert_object_location(rev, b, N, 0);
xorn_free_revision(rev);
}
static void check_not_attached(xorn_revision_t rev,
xorn_object_t ob0, xorn_object_t ob1)
{
xorn_object_t *objects;
size_t count;
assert(xorn_get_objects(rev, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 2);
assert(objects[0] == ob0);
assert(objects[1] == ob1);
free(objects);
assert(xorn_relocate_object(rev, ob0, NULL, NULL) == 0);
assert(xorn_get_objects(rev, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 2);
assert(objects[0] == ob1);
assert(objects[1] == ob0);
free(objects);
assert(xorn_relocate_object(rev, ob0, NULL, ob1) == 0);
}
static void check(xorn_revision_t rev, xorn_object_t ob,
xorn_object_t attach_to, xorn_object_t insert_before,
int result,
xorn_object_t ob0, xorn_object_t ob1, xorn_object_t ob2)
{
xorn_object_t *objects;
size_t count;
assert(xorn_relocate_object(
rev, ob, attach_to, insert_before) == result);
assert(xorn_get_objects(rev, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 3);
assert(objects[0] == ob0);
assert(objects[1] == ob1);
assert(objects[2] == ob2);
free(objects);
}
static void relocate_and_assert_2(
xorn_revision_t rev,
xorn_object_t ob, xorn_object_t insert_before,
xorn_error_t expected_result,
xorn_object_t ob0, xorn_object_t ob1)
{
xorn_error_t err;
xorn_object_t *objects;
size_t count;
err = E_OK;
assert(xorn_relocate_object(rev, ob, NULL, insert_before, &err)
== (expected_result == E_OK ? 0 : -1));
assert(err == expected_result);
assert(xorn_get_objects(rev, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 2);
assert(objects[0] == ob0);
assert(objects[1] == ob1);
free(objects);
}
static PyObject *Revision_relocate_object(
Revision *self, PyObject *args, PyObject *kwds)
{
PyObject *ob_arg = NULL, *attach_to_arg = NULL,
*insert_before_arg = NULL;
static char *kwlist[] = { "ob", "attach_to", "insert_before", NULL };
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O!OO:Revision.relocate_object", kwlist,
&ObjectType, &ob_arg, &attach_to_arg, &insert_before_arg))
return NULL;
if (attach_to_arg != Py_None &&
!PyObject_TypeCheck(attach_to_arg, &ObjectType)) {
char buf[BUFSIZ];
snprintf(buf, BUFSIZ, "Revision.relocate_object() argument 2 "
"must be %.50s or None, not %.50s",
ObjectType.tp_name,
attach_to_arg->ob_type->tp_name);
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
if (insert_before_arg != Py_None &&
!PyObject_TypeCheck(insert_before_arg, &ObjectType)) {
char buf[BUFSIZ];
snprintf(buf, BUFSIZ, "Revision.relocate_object() argument 3 "
"must be %.50s or None, not %.50s",
ObjectType.tp_name,
insert_before_arg->ob_type->tp_name);
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
if (!xorn_revision_is_transient(self->rev))
return not_transient();
xorn_obtype_t ob_type = xorn_get_object_type(
self->rev, ((Object *)ob_arg)->ob);
if (ob_type == xorn_obtype_none) {
PyErr_SetString(PyExc_KeyError, "Object does not exist");
return NULL;
}
if (attach_to_arg != Py_None) {
if (ob_type != xornsch_obtype_text) {
PyErr_SetString(PyExc_ValueError,
"Only text objects can be attached");
return NULL;
}
switch (xorn_get_object_type(self->rev,
((Object *)attach_to_arg)->ob)) {
case xorn_obtype_none:
PyErr_SetString(PyExc_KeyError,
"Parent object does not exist");
return NULL;
case xornsch_obtype_net:
case xornsch_obtype_component:
break;
default:
PyErr_SetString(PyExc_ValueError,
"Can only attach to net and "
"component objects");
return NULL;
}
}
if (insert_before_arg != Py_None) {
xorn_object_t attached_to;
if (xorn_get_object_location(
self->rev, ((Object *)insert_before_arg)->ob,
&attached_to, NULL) == -1) {
PyErr_SetString(PyExc_KeyError,
"Reference object does not exist");
return NULL;
}
if (attached_to != (attach_to_arg == Py_None ? NULL :
((Object *)attach_to_arg)->ob)) {
PyErr_SetString(PyExc_ValueError,
"Invalid reference object");
return NULL;
}
}
if (xorn_relocate_object(self->rev, ((Object *)ob_arg)->ob,
attach_to_arg == Py_None ? NULL :
((Object *)attach_to_arg)->ob,
insert_before_arg == Py_None ? NULL :
((Object *)insert_before_arg)->ob) == -1)
return PyErr_NoMemory();
Py_INCREF(Py_None);
return Py_None;
}
int main()
{
xorn_revision_t rev;
xorn_object_t ob0, ob1;
struct xornsch_line line_data;
struct xornsch_net net_data;
struct xornsch_component component_data;
struct xornsch_text text_data;
memset(&line_data, 0, sizeof line_data);
memset(&net_data, 0, sizeof net_data);
memset(&component_data, 0, sizeof component_data);
memset(&text_data, 0, sizeof text_data);
assert(rev = xorn_new_revision(NULL));
assert(ob0 = xornsch_add_line(rev, &line_data));
assert(ob1 = xornsch_add_line(rev, &line_data));
assert(xornsch_set_net_data(rev, ob0, &net_data) == 0);
assert(xornsch_set_text_data(rev, ob1, &text_data) == 0);
check_not_attached(rev, ob0, ob1);
/* data can be set without the object being reordered */
assert(xornsch_set_line_data(rev, ob0, &line_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_net_data(rev, ob0, &net_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_line_data(rev, ob1, &line_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_net_data(rev, ob1, &net_data) == 0);
check_not_attached(rev, ob0, ob1);
/* objects are re-added at the end */
xorn_delete_object(rev, ob0);
assert(xornsch_set_line_data(rev, ob0, &line_data) == 0);
check_not_attached(rev, ob1, ob0);
xorn_delete_object(rev, ob0);
assert(xornsch_set_line_data(rev, ob0, &line_data) == 0);
check_not_attached(rev, ob1, ob0);
xorn_delete_object(rev, ob1);
assert(xornsch_set_line_data(rev, ob1, &line_data) == 0);
check_not_attached(rev, ob0, ob1);
xorn_delete_object(rev, ob1);
assert(xornsch_set_line_data(rev, ob1, &line_data) == 0);
check_not_attached(rev, ob0, ob1);
xorn_delete_object(rev, ob0);
assert(xornsch_set_net_data(rev, ob0, &net_data) == 0);
check_not_attached(rev, ob1, ob0);
xorn_delete_object(rev, ob0);
assert(xornsch_set_net_data(rev, ob0, &net_data) == 0);
check_not_attached(rev, ob1, ob0);
xorn_delete_object(rev, ob1);
assert(xornsch_set_net_data(rev, ob1, &net_data) == 0);
check_not_attached(rev, ob0, ob1);
xorn_delete_object(rev, ob1);
assert(xornsch_set_net_data(rev, ob1, &net_data) == 0);
check_not_attached(rev, ob0, ob1);
/* can change ob0 to any type while no object is attached */
assert(xornsch_set_line_data(rev, ob0, &line_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_component_data(rev, ob0, &component_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_text_data(rev, ob0, &text_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_net_data(rev, ob0, &net_data) == 0);
check_not_attached(rev, ob0, ob1);
/* can change type of ob1 while not attached */
assert(xornsch_set_line_data(rev, ob1, &line_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_net_data(rev, ob1, &net_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_component_data(rev, ob1, &component_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xornsch_set_text_data(rev, ob1, &text_data) == 0);
check_not_attached(rev, ob0, ob1);
assert(xorn_relocate_object(rev, ob1, ob0, NULL) == 0);
check_attached(rev, ob0, ob1);
/* can't change ob0 to line or text while an object is attached */
assert(xornsch_set_line_data(rev, ob0, &line_data) == -1);
check_attached(rev, ob0, ob1);
assert(xornsch_set_net_data(rev, ob0, &net_data) == 0);
check_attached(rev, ob0, ob1);
assert(xornsch_set_component_data(rev, ob0, &component_data) == 0);
check_attached(rev, ob0, ob1);
assert(xornsch_set_text_data(rev, ob0, &text_data) == -1);
check_attached(rev, ob0, ob1);
/* can't change type of ob1 while attached */
assert(xornsch_set_line_data(rev, ob1, &line_data) == -1);
check_attached(rev, ob0, ob1);
assert(xornsch_set_net_data(rev, ob1, &net_data) == -1);
check_attached(rev, ob0, ob1);
assert(xornsch_set_component_data(rev, ob1, &component_data) == -1);
check_attached(rev, ob0, ob1);
assert(xornsch_set_text_data(rev, ob1, &text_data) == 0);
check_attached(rev, ob0, ob1);
xorn_free_revision(rev);
return 0;
}
int main()
{
xorn_revision_t rev;
struct xornsch_net net_data;
struct xornsch_text text_data;
xorn_object_t N, a, b;
assert(rev = xorn_new_revision(NULL));
memset(&net_data, 0, sizeof net_data);
assert(N = xornsch_add_net(rev, &net_data));
memset(&text_data, 0, sizeof text_data);
assert(a = xornsch_add_text(rev, &text_data));
assert(b = xornsch_add_text(rev, &text_data));
assert_attached_objects_3(rev, _, N, a, b);
assert_attached_objects_0(rev, N);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
assert(xorn_relocate_object(rev, N, _, _) == 0);
assert_attached_objects_3(rev, _, a, b, N);
assert_attached_objects_0(rev, N);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
assert(xorn_relocate_object(rev, N, _, b) == 0);
assert_attached_objects_3(rev, _, a, N, b);
assert_attached_objects_0(rev, N);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
assert(xorn_relocate_object(rev, a, N, _) == 0);
assert_attached_objects_2(rev, _, N, b);
assert_attached_objects_1(rev, N, a);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
assert(xorn_relocate_object(rev, b, N, _) == 0);
assert_attached_objects_1(rev, _, N);
assert_attached_objects_2(rev, N, a, b);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
assert(xorn_relocate_object(rev, a, N, _) == 0);
assert_attached_objects_1(rev, _, N);
assert_attached_objects_2(rev, N, b, a);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
assert(xorn_relocate_object(rev, a, N, b) == 0);
assert_attached_objects_1(rev, _, N);
assert_attached_objects_2(rev, N, a, b);
assert_attached_objects_0(rev, a);
assert_attached_objects_0(rev, b);
xorn_delete_object(rev, b);
assert_attached_objects_1(rev, _, N);
assert_attached_objects_1(rev, N, a);
assert_attached_objects_0(rev, a);
assert_attached_objects_f(rev, b);
xorn_delete_object(rev, N);
assert_attached_objects_0(rev, _);
assert_attached_objects_f(rev, N);
assert_attached_objects_f(rev, a);
assert_attached_objects_f(rev, b);
xorn_free_revision(rev);
return 0;
}
int main(void)
{
xorn_revision_t src, dest;
struct xornsch_net net_data;
struct xornsch_text text_data;
xorn_object_t net0, net1, text0, text1, copy;
xorn_selection_t sel, copies;
assert(src = xorn_new_revision(NULL));
memset(&net_data, 0, sizeof net_data);
net_data.color = 1;
assert(net0 = xornsch_add_net(src, &net_data, NULL));
net_data.color = 2;
assert(net1 = xornsch_add_net(src, &net_data, NULL));
memset(&text_data, 0, sizeof text_data);
text_data.color = 3;
assert(text0 = xornsch_add_text(src, &text_data, NULL));
text_data.color = 4;
assert(text1 = xornsch_add_text(src, &text_data, NULL));
assert(xorn_relocate_object(src, text1, net1, NULL, NULL) == 0);
xorn_finalize_revision(src);
/* text1 is attached to net1, text0 is not attached */
assert(dest = xorn_new_revision(NULL));
assert(copy = xorn_copy_object(dest, src, net0, NULL));
assert_this_net(dest, copy, 1);
xorn_free_revision(dest);
assert(dest = xorn_new_revision(NULL));
assert(copy = xorn_copy_object(dest, src, net1, NULL));
assert_this_net_with_text(dest, copy, 2, 4);
xorn_free_revision(dest);
assert(dest = xorn_new_revision(NULL));
assert(sel = xorn_select_object(net0));
assert(copies = xorn_copy_objects(dest, src, sel, NULL));
assert_this_net(dest, get_only_selected_object(dest, copies), 1);
xorn_free_selection(copies);
xorn_free_selection(sel);
xorn_free_revision(dest);
assert(dest = xorn_new_revision(NULL));
assert(sel = xorn_select_object(net1));
assert(copies = xorn_copy_objects(dest, src, sel, NULL));
assert_this_net_with_text(
dest, get_only_selected_object(dest, copies), 2, 4);
xorn_free_selection(copies);
xorn_free_selection(sel);
xorn_free_revision(dest);
assert(dest = xorn_new_revision(NULL));
assert(sel = xorn_select_attached_to(src, NULL));
assert(copies = xorn_copy_objects(dest, src, sel, NULL));
assert_four(dest, copies, 1, 2, 3, 4);
xorn_free_selection(copies);
xorn_free_selection(sel);
xorn_free_revision(dest);
xorn_free_revision(src);
return 0;
}
int main(void)
{
xorn_revision_t rev;
rev = xorn_new_revision(NULL);
{
/** [add object] */
struct xornsch_line line_data;
memset(&line_data, 0, sizeof line_data);
line_data.pos.x = 0;
line_data.pos.y = 0;
line_data.size.x = 100;
line_data.size.y = 100;
line_data.line.width = 1;
xorn_object_t ob;
ob = xorn_add_object(rev, xornsch_obtype_line, &line_data);
if (ob == NULL)
/* handle error */;
/** [add object] */
/** [get object data] */
const struct xornsch_line *data;
data = xorn_get_object_data(rev, ob, xornsch_obtype_line);
if (data == NULL)
/* ob doesn't exist or isn't a line */;
/** [get object data] */
}
{
struct xornsch_net net_data;
xorn_object_t ob;
memset(&net_data, 0, sizeof net_data);
ob = xornsch_add_net(rev, &net_data);
/** [set object data] */
struct xornsch_line line_data;
memset(&line_data, 0, sizeof line_data);
line_data.pos.x = 0;
line_data.pos.y = 0;
line_data.size.x = 100;
line_data.size.y = 100;
line_data.line.width = 1;
if (xorn_set_object_data(rev, ob, xornsch_obtype_line, &line_data) == -1)
/* handle error */;
/** [set object data] */
}
{
/** [get objects] */
xorn_object_t *objects;
size_t count;
unsigned int i;
if (xorn_get_objects(rev, &objects, &count) == -1)
/* handle error */;
for (i = 0; i < count; i++)
/* do something with objects[i] */;
free(objects);
/** [get objects] */
}
{
struct xornsch_component component_data;
xorn_object_t component;
memset(&component_data, 0, sizeof component_data);
component = xornsch_add_component(rev, &component_data);
/** [add attribute] */
struct xornsch_text text_data;
memset(&text_data, 0, sizeof text_data);
text_data.text.s = "refdes=R1";
text_data.text.len = strlen(text_data.text.s);
xorn_object_t ob;
ob = xornsch_add_text(rev, &text_data);
if (ob == NULL)
/* handle error */;
if (xorn_relocate_object(rev, ob, component, NULL) == -1)
/* handle error */;
/** [add attribute] */
}
xorn_free_revision(rev);
return 0;
}
