int main(void)
{
xorn_revision_t rev0, rev1, rev2;
xorn_object_t ob;
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;
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;
rev0 = xorn_new_revision(NULL);
assert(rev0 != NULL);
assert(xorn_revision_is_transient(rev0) == true);
xorn_finalize_revision(rev0);
assert(xorn_revision_is_transient(rev0) == false);
rev1 = xorn_new_revision(rev0);
assert(rev1 != NULL);
assert(xorn_revision_is_transient(rev1) == true);
ob = xornsch_add_line(rev1, &line_data, NULL);
assert(ob != NULL);
xorn_finalize_revision(rev1);
assert(xorn_revision_is_transient(rev1) == false);
try_modify(rev1, ob, false);
rev2 = xorn_new_revision(rev1);
assert(rev2 != NULL);
assert(xorn_revision_is_transient(rev2) == true);
try_modify(rev2, ob, true);
xorn_finalize_revision(rev2);
assert(xorn_revision_is_transient(rev2) == false);
xorn_free_revision(rev2);
xorn_free_revision(rev1);
xorn_free_revision(rev0);
return 0;
}
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 rev0, rev1, rev2, rev3;
xorn_object_t ob0, ob1a, ob1b;
xorn_revision_t rev4;
setup(&rev0, &rev1, &rev2, &rev3, &ob0, &ob1a, &ob1b);
rev4 = xorn_new_revision(rev3);
assert(rev4 != NULL);
assert(xornsch_add_line(rev4, NULL) == NULL);
assert(xornsch_set_line_data(rev4, ob0, NULL) == -1);
xorn_finalize_revision(rev4);
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(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;
}
