PyObject *Revision_copy_object(
Revision *self, PyObject *args, PyObject *kwds)
{
PyObject *rev_arg = NULL, *ob_arg = NULL;
static char *kwlist[] = { "rev", "ob", NULL };
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O!O!:Revision.copy_object", kwlist,
&RevisionType, &rev_arg, &ObjectType, &ob_arg))
return NULL;
if (!xorn_revision_is_transient(self->rev))
return not_transient();
if (!xorn_object_exists_in_revision(((Revision *)rev_arg)->rev,
((Object *)ob_arg)->ob)) {
PyErr_SetString(PyExc_KeyError,
"Object does not exist in source revision");
return NULL;
}
xorn_object_t ob = xorn_copy_object(
self->rev, ((Revision *)rev_arg)->rev,
((Object *)ob_arg)->ob);
return ob ? build_object(ob) : PyErr_NoMemory();
}
static void check_order(void)
{
xorn_revision_t rev0, rev1, rev2, rev3, rev4;
xorn_object_t ob0, ob1a, ob1b, ob2;
struct xornsch_arc arc_data;
setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
assert_object_location_fails(rev0, ob0);
assert_object_location_fails(rev0, ob1a);
assert_object_location_fails(rev0, ob1b);
assert_object_location(rev1, ob0, NULL, 0);
assert_object_location_fails(rev1, ob1a);
assert_object_location_fails(rev1, ob1b);
assert_object_location(rev2, ob0, NULL, 0);
assert_object_location(rev2, ob1a, NULL, 1);
assert_object_location(rev2, ob1b, NULL, 2);
assert_object_location(rev3, ob0, NULL, 0);
assert_object_location_fails(rev3, ob1a);
assert_object_location(rev3, ob1b, NULL, 1);
rev4 = xorn_new_revision(rev3);
memset(&arc_data, 0, sizeof arc_data);
assert(xornsch_set_arc_data(rev4, ob1a, &arc_data) == 0);
assert_object_location(rev4, ob0, NULL, 0);
assert_object_location(rev4, ob1a, NULL, 2);
assert_object_location(rev4, ob1b, NULL, 1);
ob2 = xorn_copy_object(rev4, rev1, ob0);
assert(ob2 != NULL);
assert_object_location(rev4, ob0, NULL, 0);
assert_object_location(rev4, ob1a, NULL, 2);
assert_object_location(rev4, ob1b, NULL, 1);
assert_object_location(rev4, ob2, NULL, 3);
xorn_delete_object(rev4, ob0);
assert_object_location_fails(rev4, ob0);
assert_object_location(rev4, ob1a, NULL, 1);
assert_object_location(rev4, ob1b, NULL, 0);
assert_object_location(rev4, ob2, NULL, 2);
xorn_free_revision(rev4);
xorn_free_revision(rev3);
xorn_free_revision(rev2);
xorn_free_revision(rev1);
xorn_free_revision(rev0);
}
static void try_modify(xorn_revision_t rev, xorn_object_t existing_ob,
bool expected_result)
{
xorn_object_t ob0, ob1;
xorn_selection_t sel0, sel1;
xorn_error_t err;
xorn_error_t expected_err = expected_result
? NO_ERROR : xorn_error_revision_not_transient;
err = NO_ERROR;
ob0 = xornsch_add_line(rev, &line_data, &err);
assert((ob0 != NULL) == expected_result);
assert(err == expected_err);
err = NO_ERROR;
assert((xornsch_set_box_data(rev, existing_ob, &box_data, &err) == 0)
== expected_result);
assert(err == expected_err);
err = NO_ERROR;
ob1 = xorn_copy_object(rev, rev, existing_ob, &err);
assert((ob1 != NULL) == expected_result);
assert(err == expected_err);
xorn_object_t del_ob = expected_result ? ob1 : existing_ob;
err = NO_ERROR;
assert((xorn_delete_object(rev, del_ob, &err) == 0)
== expected_result);
assert(err == expected_err);
assert(xorn_object_exists_in_revision(rev, del_ob)
== !expected_result);
sel0 = xorn_select_all(rev);
assert(sel0 != NULL);
err = NO_ERROR;
sel1 = xorn_copy_objects(rev, rev, sel0, &err);
assert((sel1 != NULL) == expected_result);
assert(err == expected_err);
xorn_free_selection(sel1);
err = NO_ERROR;
assert((xorn_delete_selected_objects(rev, sel0, &err) == 0)
== expected_result);
assert(err == expected_err);
assert(xorn_object_exists_in_revision(rev, existing_ob)
== !expected_result);
xorn_free_selection(sel0);
}
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;
}
