static PyObject *Revision_delete_object(
Revision *self, PyObject *args, PyObject *kwds)
{
PyObject *ob_arg = NULL;
static char *kwlist[] = { "ob", NULL };
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O!:Revision.delete_object", kwlist,
&ObjectType, &ob_arg))
return NULL;
if (!xorn_revision_is_transient(self->rev))
return not_transient();
if (!xorn_object_exists_in_revision(self->rev,
((Object *)ob_arg)->ob)) {
PyErr_SetString(PyExc_KeyError, "Object does not exist");
return NULL;
}
xorn_delete_object(self->rev, ((Object *)ob_arg)->ob);
Py_INCREF(Py_None);
return Py_None;
}
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);
}
static void check_delete_0(xorn_revision_t rev, xorn_object_t del)
{
xorn_revision_t r;
xorn_object_t *objects;
size_t count;
assert(r = xorn_new_revision(rev));
xorn_delete_object(r, del);
assert(xorn_get_objects(r, &objects, &count) == 0);
assert(count == 0);
free(objects);
xorn_free_revision(r);
}
int main(void)
{
xorn_revision_t rev;
rev = xorn_new_revision(NULL);
/** [discrete] */
xorn_object_t *objects;
size_t count;
unsigned int i;
xorn_get_objects(rev, &objects, &count);
for (i = 0; i < count; i++) {
xorn_obtype_t type = xorn_get_object_type(rev, objects[i]);
if (type == xornsch_obtype_circle &&
xornsch_get_circle_data(rev, objects[i])->radius == 0.)
xorn_delete_object(rev, objects[i], NULL);
if (type == xornsch_obtype_arc &&
xornsch_get_arc_data(rev, objects[i])->radius == 0.)
xorn_delete_object(rev, objects[i], NULL);
}
free(objects);
/** [discrete] */
/** [integrated] */
xorn_selection_t sel = xornsch_select_by_radius(rev, 0.);
xorn_delete_selected_objects(rev, sel, NULL);
xorn_free_selection(sel);
/** [integrated] */
xorn_free_revision(rev);
return 0;
}
static void check_delete_2(xorn_revision_t rev, xorn_object_t del,
xorn_object_t ob0, xorn_object_t ob1)
{
xorn_revision_t r;
xorn_object_t *objects;
size_t count;
assert(r = xorn_new_revision(rev));
xorn_delete_object(r, del);
assert(xorn_get_objects(r, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 2);
assert(objects[0] == ob0);
assert(objects[1] == ob1);
free(objects);
xorn_free_revision(r);
}
int main(void)
{
xorn_revision_t rev0, rev1, rev2, rev3;
xorn_object_t ob0, ob1a, ob1b;
xorn_object_t *objects;
size_t count;
xorn_revision_t rev4;
setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
rev4 = xorn_new_revision(rev2);
assert(xorn_get_objects(rev4, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 3);
assert(objects[0] == ob0);
assert(objects[1] == ob1a);
assert(objects[2] == ob1b);
free(objects);
relocate_and_assert_3(rev4, ob0, ob0, E_OK, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, ob0, ob1a, E_OK, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, ob0, ob1b, E_OK, ob1a, ob0, ob1b);
relocate_and_assert_3(rev4, ob0, NULL, E_OK, ob1a, ob1b, ob0);
relocate_and_assert_3(rev4, ob1a, ob0, E_OK, ob1b, ob1a, ob0);
relocate_and_assert_3(rev4, ob1a, ob1a, E_OK, ob1b, ob1a, ob0);
relocate_and_assert_3(rev4, ob1a, ob1b, E_OK, ob1a, ob1b, ob0);
relocate_and_assert_3(rev4, ob1a, NULL, E_OK, ob1b, ob0, ob1a);
relocate_and_assert_3(rev4, ob1b, ob0, E_OK, ob1b, ob0, ob1a);
relocate_and_assert_3(rev4, ob1b, ob1a, E_OK, ob0, ob1b, ob1a);
relocate_and_assert_3(rev4, ob1b, ob1b, E_OK, ob0, ob1b, ob1a);
relocate_and_assert_3(rev4, ob1b, NULL, E_OK, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, NULL, ob0, E_NOEXIST, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, NULL, ob1a, E_NOEXIST, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, NULL, ob1b, E_NOEXIST, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, NULL, NULL, E_NOEXIST, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, ob0, ob0, E_OK, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, ob1a, ob1a, E_OK, ob0, ob1a, ob1b);
relocate_and_assert_3(rev4, ob1b, ob1b, E_OK, ob0, ob1a, ob1b);
assert(xorn_delete_object(rev4, ob0, NULL) == 0);
assert(xorn_get_objects(rev4, &objects, &count) == 0);
assert(objects != NULL);
assert(count == 2);
assert(objects[0] == ob1a);
assert(objects[1] == ob1b);
free(objects);
relocate_and_assert_2(rev4, ob0, ob0, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, ob0, ob1a, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, ob0, ob1b, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, ob0, NULL, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1a, ob0, E_NOSUCC, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1a, ob1a, E_OK, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1a, ob1b, E_OK, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1a, NULL, E_OK, ob1b, ob1a);
relocate_and_assert_2(rev4, ob1b, ob0, E_NOSUCC, ob1b, ob1a);
relocate_and_assert_2(rev4, ob1b, ob1a, E_OK, ob1b, ob1a);
relocate_and_assert_2(rev4, ob1b, ob1b, E_OK, ob1b, ob1a);
relocate_and_assert_2(rev4, ob1b, NULL, E_OK, ob1a, ob1b);
relocate_and_assert_2(rev4, NULL, ob0, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, NULL, ob1a, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, NULL, ob1b, E_NOEXIST, ob1a, ob1b);
relocate_and_assert_2(rev4, NULL, NULL, E_NOEXIST, ob1a, ob1b);
xorn_finalize_revision(rev4);
relocate_and_assert_2(rev4, ob1a, ob1a, E_NOTRANS, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1a, ob1b, E_NOTRANS, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1a, NULL, E_NOTRANS, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1b, ob1a, E_NOTRANS, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1b, ob1b, E_NOTRANS, ob1a, ob1b);
relocate_and_assert_2(rev4, ob1b, NULL, E_NOTRANS, ob1a, ob1b);
xorn_free_revision(rev4);
xorn_free_revision(rev3);
xorn_free_revision(rev2);
xorn_free_revision(rev1);
xorn_free_revision(rev0);
return 0;
}
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 rev0, rev1, rev2, rev3;
xorn_object_t line, box, circle;
struct xornsch_line line_data;
struct xornsch_box box_data;
struct xornsch_circle circle_data;
struct xornsch_net net_data;
/* Create an empty revision and make it read-only. */
rev0 = xorn_new_revision(NULL);
if (rev0 == NULL)
goto error0;
xorn_finalize_revision(rev0);
/* Copy the revision */
/* You could omit the previous step and just create an empty
revision if you don't need to refer to the empty state later. */
rev1 = xorn_new_revision(rev0);
if (rev1 == NULL)
goto error1;
/* Prepare a xornsch_line structure */
memset(&line_data, 0, sizeof line_data);
line_data.pos.x = 0;
line_data.pos.y = 1;
line_data.size.x = 3;
line_data.size.y = 2;
line_data.color = 3;
line_data.line.width = 1;
/* Add a line object with this data to the revision */
line = xornsch_add_line(rev1, &line_data);
if (line == NULL)
goto error2;
/* Finalize the revision */
xorn_finalize_revision(rev1);
/* Create a copy of the last revision, add a box and a circle
to it, and finalize it */
rev2 = xorn_new_revision(rev1);
if (rev2 == NULL)
goto error2;
memset(&box_data, 0, sizeof box_data);
box_data.pos.x = 1;
box_data.pos.y = 1;
box_data.size.x = 2;
box_data.size.y = 2;
box_data.color = 3;
box_data.line.width = 1;
box = xornsch_add_box(rev2, &box_data);
if (box == NULL)
goto error3;
memset(&circle_data, 0, sizeof circle_data);
circle_data.pos.x = -1;
circle_data.pos.y = -1;
circle_data.radius = 2;
circle_data.color = 3;
circle_data.line.width = 1;
circle_data.fill.type = 1;
circle = xornsch_add_circle(rev2, &circle_data);
if (circle == NULL)
goto error3;
xorn_finalize_revision(rev2);
/* Create a copy of the last revision, set the line's object
type to net and change its color, delete the box, and
finalize the revision */
rev3 = xorn_new_revision(rev2);
if (rev3 == NULL)
goto error3;
memset(&net_data, 0, sizeof net_data);
net_data.pos.x = 0;
net_data.pos.y = 1;
net_data.size.x = 3;
net_data.size.y = 2;
net_data.color = 4;
if (xornsch_set_net_data(rev3, line, &net_data) == -1)
goto error4;
xorn_delete_object(rev3, box);
xorn_finalize_revision(rev3);
/* ... you could do something with these revisions now ... */
/* Free the revisions (the order doesn't matter) */
xorn_free_revision(rev3);
xorn_free_revision(rev2);
xorn_free_revision(rev1);
xorn_free_revision(rev0);
/* No need to free objects */
return 0;
error4:
xorn_free_revision(rev3);
error3:
xorn_free_revision(rev2);
error2:
xorn_free_revision(rev1);
error1:
xorn_free_revision(rev0);
error0:
fprintf(stderr, "Out of memory\n");
return 1;
}
