static void
place_spline_x(int x, int y)
{
canvas_leftbut_proc = null_proc;
canvas_middlebut_proc = null_proc;
canvas_rightbut_proc = null_proc;
canvas_locmove_proc = null_proc;
canvas_ref_proc = null_proc;
adjust_pos(x, y, fix_x, fix_y, &x, &y);
translate_spline(new_s, x - fix_x, y - fix_y);
if (return_proc == copy_selected) {
add_spline(new_s);
} else {
list_add_spline(&objects.splines, new_s);
clean_up();
set_lastposition(fix_x, fix_y);
set_newposition(x, y);
set_action_object(F_MOVE, O_SPLINE);
set_latestspline(new_s);
set_modifiedflag();
}
redisplay_spline(new_s);
/* turn back on all relevant markers */
update_markers(new_objmask);
(*return_proc) ();
draw_mousefun_canvas();
}
static void
place_line_x(int x, int y)
{
int dx, dy;
canvas_leftbut_proc = null_proc;
canvas_middlebut_proc = null_proc;
canvas_rightbut_proc = null_proc;
canvas_locmove_proc = null_proc;
canvas_ref_proc = null_proc;
adjust_pos(x, y, fix_x, fix_y, &x, &y);
dx = x - fix_x;
dy = y - fix_y;
translate_line(new_l, dx, dy);
clean_up();
set_latestline(new_l);
if (return_proc == copy_selected) {
add_line(new_l);
adjust_links(cur_linkmode, cur_links, dx, dy, 0, 0, 1.0, 1.0, True);
free_linkinfo(&cur_links);
} else {
list_add_line(&objects.lines, new_l);
adjust_links(cur_linkmode, cur_links, dx, dy, 0, 0, 1.0, 1.0, False);
set_lastposition(fix_x, fix_y);
set_newposition(x, y);
set_lastlinkinfo(cur_linkmode, cur_links);
cur_links = NULL;
set_action_object(F_MOVE, O_POLYLINE);
}
set_modifiedflag();
redisplay_line(new_l);
/* turn back on all relevant markers */
update_markers(new_objmask);
(*return_proc) ();
draw_mousefun_canvas();
}
static void
place_lib_object(int x, int y, unsigned int shift)
{
F_compound *this_c;
canvas_leftbut_proc = null_proc;
canvas_middlebut_proc = null_proc;
canvas_rightbut_proc = null_proc;
canvas_locmove_proc = null_proc;
canvas_ref_proc = null_proc;
put_draw(ERASE);
clean_up();
if (draw_box)
translate_compound(new_c,cur_x,cur_y);
/* remove it from the depths because it will be added when it is put in the main list */
remove_compound_depth(new_c);
add_compound(new_c);
set_modifiedflag();
redisplay_compound(new_c);
if (shift) {
/* temporarily turn off library place mode so we can edit the object just placed */
canvas_kbd_proc = null_proc;
clear_mousefun();
set_mousefun("","","", "", "", "");
turn_off_current();
set_cursor(arrow_cursor);
edit_remember_lib_mode = True;
this_c = new_c;
edit_item(this_c, O_COMPOUND, 0, 0);
} else {
put_selected();
}
}
static void
relocate_splinepoint(F_spline *s, int x, int y, F_point *moved_point)
{
moved_point->x = x;
moved_point->y = y;
set_modifiedflag();
}
static void
add_linearrow(F_line *line, F_point *prev_point, F_point *selected_point)
{
if (line->points->next == NULL)
return; /* A single point line */
if (prev_point == NULL) { /* selected_point is the first point */
if (line->back_arrow)
return;
line->back_arrow = backward_arrow();
redisplay_line(line);
} else if (selected_point->next == NULL) { /* forward arrow */
if (line->for_arrow)
return;
line->for_arrow = forward_arrow();
redisplay_line(line);
} else
return;
clean_up();
set_last_prevpoint(prev_point);
set_last_selectedpoint(selected_point);
set_latestline(line);
set_action_object(F_ADD_ARROW_HEAD, O_POLYLINE);
set_modifiedflag();
}
static void
fix_movedcompoundpoint(int x, int y)
{
float scalex, scaley;
canvas_ref_proc = canvas_locmove_proc = null_proc;
elastic_box(fix_x, fix_y, cur_x, cur_y);
/* erase last lengths if appres.showlengths is true */
erase_lengths();
adjust_box_pos(x, y, from_x, from_y, &cur_x, &cur_y);
/* make a copy of the original and save as unchanged object */
old_c = copy_compound(cur_c);
clean_up();
old_c->next = cur_c;
set_latestcompound(old_c);
set_action_object(F_EDIT, O_COMPOUND);
scalex = ((float) (cur_x - fix_x)) / (from_x - fix_x);
scaley = ((float) (cur_y - fix_y)) / (from_y - fix_y);
/* scale the compound */
scale_compound(cur_c, scalex, scaley, fix_x, fix_y);
/* redraw anything under the old compound */
redisplay_compound(old_c);
/* and the new compound */
redisplay_compound(cur_c);
/* turn back on all relevant markers */
update_markers(new_objmask);
set_lastposition(from_x, from_y);
set_newposition(cur_x, cur_y);
set_modifiedflag();
wrapup_movepoint();
}
void
delete_splinearrow(F_spline *spline, F_point *prev_point, F_point *selected_point)
{
if (closed_spline(spline))
return;
if (prev_point == NULL) { /* selected_point is the first point */
if (!spline->back_arrow)
return;
draw_spline(spline, ERASE);
saved_back_arrow=spline->back_arrow;
if (saved_for_arrow && saved_for_arrow != spline->for_arrow)
free((char *) saved_for_arrow);
saved_for_arrow = NULL;
spline->back_arrow = NULL;
redisplay_spline(spline);
} else if (selected_point->next == NULL) { /* forward arrow */
if (!spline->for_arrow)
return;
draw_spline(spline, ERASE);
saved_for_arrow=spline->for_arrow;
if (saved_back_arrow && saved_back_arrow != spline->back_arrow)
free((char *) saved_back_arrow);
saved_back_arrow = NULL;
spline->for_arrow = NULL;
redisplay_spline(spline);
} else
return;
clean_up();
set_last_prevpoint(prev_point);
set_last_selectedpoint(selected_point);
set_latestspline(spline);
set_action_object(F_DELETE_ARROW_HEAD, O_SPLINE);
set_modifiedflag();
}
void
delete_arcarrow(F_arc *arc, int point_num)
{
if (arc->type == T_PIE_WEDGE_ARC)
return;;
if (point_num == 0) { /* backward arrow */
if (!arc->back_arrow)
return;
draw_arc(arc, ERASE);
saved_back_arrow=arc->back_arrow;
if (saved_for_arrow && saved_for_arrow != arc->for_arrow)
free((char *) saved_for_arrow);
saved_for_arrow = NULL;
arc->back_arrow = NULL;
redisplay_arc(arc);
} else if (point_num == 2) {/* for_arrow */
if (!arc->for_arrow)
return;
draw_arc(arc, ERASE);
saved_for_arrow=arc->for_arrow;
if (saved_back_arrow && saved_back_arrow != arc->back_arrow)
free((char *) saved_back_arrow);
saved_back_arrow = NULL;
arc->for_arrow = NULL;
redisplay_arc(arc);
} else
return;
clean_up();
set_last_arcpointnum(point_num);
set_latestarc(arc);
set_action_object(F_DELETE_ARROW_HEAD, O_ARC);
set_modifiedflag();
}
void
delete_linearrow(F_line *line, F_point *prev_point, F_point *selected_point)
{
if (line->points->next == NULL)
return; /* A single point line */
if (prev_point == NULL) { /* selected_point is the first point */
if (!line->back_arrow)
return;
draw_line(line, ERASE);
saved_back_arrow=line->back_arrow;
if (saved_for_arrow && saved_for_arrow != line->for_arrow)
free((char *) saved_for_arrow);
saved_for_arrow = NULL;
line->back_arrow = NULL;
redisplay_line(line);
} else if (selected_point->next == NULL) { /* forward arrow */
if (!line->for_arrow)
return;
draw_line(line, ERASE);
saved_for_arrow=line->for_arrow;
if (saved_back_arrow && saved_back_arrow != line->back_arrow)
free((char *) saved_back_arrow);
saved_back_arrow = NULL;
line->for_arrow = NULL;
redisplay_line(line);
} else
return;
clean_up();
set_last_prevpoint(prev_point);
set_last_selectedpoint(selected_point);
set_latestline(line);
set_action_object(F_DELETE_ARROW_HEAD, O_POLYLINE);
set_modifiedflag();
}
void
box_2_box(F_line *old_l)
{
F_line *new_l;
new_l = copy_line(old_l);
switch (old_l->type) {
case T_BOX:
new_l->type = T_ARCBOX;
if (new_l->radius == DEFAULT || new_l->radius == 0)
new_l->radius = cur_boxradius;
break;
case T_ARCBOX:
new_l->type = T_BOX;
break;
}
list_delete_line(&objects.lines, old_l);
list_add_line(&objects.lines, new_l);
clean_up();
old_l->next = new_l;
set_latestline(old_l);
set_action_object(F_CONVERT, O_POLYLINE);
set_modifiedflag();
/* save pointer to this line for undo */
latest_line = new_l;
redisplay_line(new_l);
return;
}
static void
add_arcarrow(F_arc *arc, int point_num)
{
/* only allow arrowheads on open arc */
if (arc->type == T_PIE_WEDGE_ARC)
return;
if (point_num == 0) { /* backward arrow */
if (arc->back_arrow)
return;
arc->back_arrow = backward_arrow();
redisplay_arc(arc);
} else if (point_num == 2) {/* for_arrow */
if (arc->for_arrow)
return;
arc->for_arrow = forward_arrow();
redisplay_arc(arc);
} else
return;
clean_up();
set_last_arcpointnum(point_num);
set_latestarc(arc);
set_action_object(F_ADD_ARROW_HEAD, O_ARC);
set_modifiedflag();
}
static void
init_align_canvas(int x, int y, unsigned int shift)
/* Shift Key Status from XEvent */
{
int ux;
cur_c = &objects;
toggle_all_compoundmarkers();
draw_compoundelements(cur_c, ERASE);
old_c = copy_compound(&objects);
xcmin=ycmin=0;
/* get the current page size */
xcmax = paper_sizes[appres.papersize].width;
ycmax = paper_sizes[appres.papersize].height;
if (!appres.INCHES) {
xcmax = (int)(xcmax*2.54*PIX_PER_CM/PIX_PER_INCH);
ycmax = (int)(ycmax*2.54*PIX_PER_CM/PIX_PER_INCH);
}
/* swap height and width if landscape */
if (appres.landscape) {
ux = xcmax;
xcmax = ycmax;
ycmax = ux;
}
align_ellipse();
align_arc();
align_line();
align_spline();
align_compound();
align_text();
/*
* Display messages indicating that distribution or alignment can't be
* performed with respect to the canvas.
*/
if ((cur_halign == ALIGN_DISTRIB_C) || (cur_halign == ALIGN_DISTRIB_E))
put_msg("Can't DISTRIBUTE horizontally with respect to the canvas");
else if (cur_halign == ALIGN_ABUT)
put_msg("Can't ABUT horizontally with respect to the canvas");
if ((cur_valign == ALIGN_DISTRIB_C) || (cur_valign == ALIGN_DISTRIB_E))
put_msg("Can't DISTRIBUTE vertically with respect to the canvas");
else if (cur_valign == ALIGN_ABUT)
put_msg("Can't ABUT vertically with respect to the canvas");
draw_compoundelements(cur_c, PAINT);
toggle_all_compoundmarkers();
clean_up();
set_latestobjects(old_c);
set_action_object(F_EDIT, O_ALL_OBJECT);
set_modifiedflag();
}
static void
relocate_linepoint(F_line *line, int x, int y, F_point *moved_point, F_point *left_point)
{
if (line->type == T_POLYGON)
if (line->points == moved_point) {
left_point->next->x = x;
left_point->next->y = y;
}
moved_point->x = x;
moved_point->y = y;
set_modifiedflag();
}
static void
do_update(Widget widget, XtPointer closure, XtPointer call_data)
{
if (found_text_cnt > 0) {
search_text_in_compound(&objects,
panel_get_value(search_text_widget), update_text);
found_text_panel_dismiss();
redisplay_canvas();
set_modifiedflag();
show_search_msg("%d object%s updated",
found_text_cnt, (found_text_cnt != 1)? "s":"");
}
}
void
toggle_polyline_polygon(F_line *line, F_point *previous_point, F_point *selected_point)
{
F_point *point, *last_pt;
last_pt = last_point(line->points);
if (line->type == T_POLYLINE)
{
if (line->points->next == NULL || line->points->next->next == NULL) {
put_msg("Not enough points for a polygon");
beep();
return; /* less than 3 points - don't close the polyline */
}
if ((point = create_point()) == NULL)
return;
point->x = last_pt->x;
point->y = last_pt->y;
point->next = line->points;
line->points = point;
line->type = T_POLYGON;
clean_up();
set_last_arrows(line->for_arrow, line->back_arrow);
line->back_arrow = line->for_arrow = NULL;
}
else if (line->type == T_POLYGON)
{
point = line->points;
line->points = point->next; /* unchain the first point */
free((char *) point);
if ((line->points != selected_point) && (previous_point != NULL))
{
last_pt->next = line->points; /* let selected point become */
previous_point->next = NULL; /* first point */
line->points = selected_point;
}
line->type = T_POLYLINE;
clean_up();
}
redisplay_line(line);
set_action_object(F_OPEN_CLOSE, O_POLYLINE);
set_last_selectedpoint(line->points);
set_last_prevpoint(NULL);
set_latestline(line);
set_modifiedflag();
}
void
linepoint_deleting(F_line *line, F_point *prev_point, F_point *selected_point)
{
F_point *p, *next_point;
next_point = selected_point->next;
/* delete it and redraw underlying objects */
list_delete_line(&objects.lines, line);
redisplay_line(line);
if (line->type == T_POLYGON) {
if (prev_point == NULL) {
/* The deleted point is the first point */
line->points = next_point;
for (prev_point = next_point, p = prev_point->next;
p->next != NULL;
prev_point = p, p = p->next);
/*
* prev_point now points at next to last point (the last point is
* a copy of the first).
*/
p->x = next_point->x;
p->y = next_point->y;
next_point = p;
/*
* next_point becomes the last point. If this operation (point
* deletion) is reversed (undo), the selected_point will not be
* inserted into it original place, but will be between
* prev_point and next_point.
*/
} else
prev_point->next = next_point;
} else { /* polyline */
if (prev_point == NULL)
line->points = next_point;
else
prev_point->next = next_point;
}
/* put it back in the list and draw the new line */
list_add_line(&objects.lines, line);
/* redraw it and anything on top of it */
redisplay_line(line);
clean_up();
set_modifiedflag();
set_action_object(F_DELETE_POINT, O_POLYLINE);
set_latestline(line);
set_last_prevpoint(prev_point);
set_last_selectedpoint(selected_point);
set_last_nextpoint(next_point);
}
static void
create_compoundobject(int x, int y)
{
F_compound *c;
if ((c = create_compound()) == NULL)
return;
if (compose_compound(c) == 0) {
free((char *) c);
compound_selected();
draw_mousefun_canvas();
put_msg("Empty compound, ignored");
return;
}
/*
* Make the bounding box exactly match the dimensions of the compound.
*/
compound_bound(c, &c->nwcorner.x, &c->nwcorner.y,
&c->secorner.x, &c->secorner.y);
/* if zero width or height in the compound, adjust to next positioning
grid point or a few pixels if positioning grid is "ANY" */
if (c->nwcorner.x == c->secorner.x) {
if (cur_pointposn != P_ANY) {
c->secorner.x += posn_rnd[cur_gridunit][cur_pointposn];
c->secorner.x = ceil_coords_x(c->secorner.x,c->secorner.y);
}
}
if (c->nwcorner.y == c->secorner.y) {
if (cur_pointposn != P_ANY) {
c->secorner.y += posn_rnd[cur_gridunit][cur_pointposn];
c->secorner.y = ceil_coords_y(c->secorner.x,c->secorner.y);
}
}
c->next = NULL;
clean_up();
set_action(F_GLUE);
toggle_markers_in_compound(c);
list_add_compound(&objects.compounds, c);
mask_toggle_compoundmarker(c);
set_latestcompound(c);
set_modifiedflag();
compound_selected();
draw_mousefun_canvas();
}
void
splinepoint_deleting(F_spline *spline, F_point *previous_point, F_point *selected_point)
{
F_point *next_point;
F_sfactor *s_prev_point, *selected_sfactor;
next_point = selected_point->next;
set_temp_cursor(wait_cursor);
clean_up();
set_last_prevpoint(previous_point);
/* delete it and redraw underlying objects */
list_delete_spline(&objects.splines, spline);
draw_spline(spline, ERASE);
redisplay_spline(spline);
if (previous_point == NULL) {
spline->points = next_point;
if (open_spline(spline)) {
selected_sfactor = spline->sfactors->next;
spline->sfactors->next = selected_sfactor->next;
} else {
selected_sfactor = spline->sfactors;
spline->sfactors = spline->sfactors->next;
}
} else {
previous_point->next = next_point;
if ((next_point == NULL) && (open_spline(spline)))
previous_point = prev_point(spline->points, previous_point);
s_prev_point = search_sfactor(spline,previous_point);
selected_sfactor = s_prev_point->next;
s_prev_point->next = s_prev_point->next->next;
}
/* put it back in the list and draw the new spline */
list_add_spline(&objects.splines, spline);
/* redraw it and anything on top of it */
redisplay_spline(spline);
set_action_object(F_DELETE_POINT, O_SPLINE);
set_latestspline(spline);
set_last_selectedpoint(selected_point);
set_last_selectedsfactor(selected_sfactor);
set_last_nextpoint(next_point);
set_modifiedflag();
reset_cursor();
}
static void
place_lib_object_orig(int x, int y, unsigned int shift)
{
int dx,dy;
canvas_ref_proc = null_proc;
put_draw(ERASE);
clean_up();
/* move back to original position */
dx = orig_put_x-x;
dy = orig_put_y-y;
translate_compound(new_c,dx,dy);
/* remove it from the depths because it will be added when it is put in the main list */
remove_compound_depth(new_c);
add_compound(new_c);
set_modifiedflag();
redisplay_compound(new_c);
put_selected();
}
static void
add_splinearrow(F_spline *spline, F_point *prev_point, F_point *selected_point)
{
if (prev_point == NULL) { /* add backward arrow */
if (spline->back_arrow)
return;
spline->back_arrow = backward_arrow();
redisplay_spline(spline);
} else if (selected_point->next == NULL) { /* add forward arrow */
if (spline->for_arrow)
return;
spline->for_arrow = forward_arrow();
redisplay_spline(spline);
}
clean_up();
set_last_prevpoint(prev_point);
set_last_selectedpoint(selected_point);
set_latestspline(spline);
set_action_object(F_ADD_ARROW_HEAD, O_SPLINE);
set_modifiedflag();
}
static void
init_align(F_line *p, int type, int x, int y, int px, int py)
{
if (type != O_COMPOUND)
return;
cur_c = (F_compound *) p;
toggle_compoundmarker(cur_c);
draw_compoundelements(cur_c, ERASE);
old_c = copy_compound(cur_c);
compound_bound(cur_c, &xcmin, &ycmin, &xcmax, &ycmax);
align_ellipse();
align_arc();
align_line();
align_spline();
align_compound();
align_text();
/*
* Perform the distribution of the objects in the compound
*/
if ( (cur_halign == ALIGN_DISTRIB_C) || (cur_halign == ALIGN_DISTRIB_E)
|| (cur_halign == ALIGN_ABUT) )
distribute_horizontally();
if ( (cur_valign == ALIGN_DISTRIB_C) || (cur_valign == ALIGN_DISTRIB_E)
|| (cur_valign == ALIGN_ABUT) )
distribute_vertically();
/*
* recompute the compound's bounding box
*/
compound_bound(cur_c, &cur_c->nwcorner.x, &cur_c->nwcorner.y,
&cur_c->secorner.x, &cur_c->secorner.y);
draw_compoundelements(cur_c, PAINT);
toggle_compoundmarker(cur_c);
clean_up();
old_c->next = cur_c;
set_latestcompound(old_c);
set_action_object(F_EDIT, O_COMPOUND);
set_modifiedflag();
}
void undo_change(void)
{
char *swp_comm;
F_compound swp_c;
F_line swp_l;
F_spline swp_s;
F_ellipse swp_e;
F_arc swp_a;
F_text swp_t;
last_action = F_NULL; /* to avoid a clean-up during "unchange" */
switch (last_object) {
case O_POLYLINE:
new_l = saved_objects.lines; /* the original */
old_l = saved_objects.lines->next; /* the changed object */
/* account for depths */
remove_depth(O_POLYLINE, old_l->depth);
add_depth(O_POLYLINE, new_l->depth);
/* swap old with new */
bcopy((char*)old_l, (char*)&swp_l, sizeof(F_line));
bcopy((char*)new_l, (char*)old_l, sizeof(F_line));
bcopy((char*)&swp_l, (char*)new_l, sizeof(F_line));
/* but keep the next pointers unchanged */
swp_l.next = old_l->next;
old_l->next = new_l->next;
new_l->next = swp_l.next;
set_action_object(F_EDIT, O_POLYLINE);
redisplay_lines(new_l, old_l);
break;
case O_ELLIPSE:
new_e = saved_objects.ellipses;
old_e = saved_objects.ellipses->next;
/* account for depths */
remove_depth(O_ELLIPSE, old_e->depth);
add_depth(O_ELLIPSE, new_e->depth);
/* swap old with new */
bcopy((char*)old_e, (char*)&swp_e, sizeof(F_ellipse));
bcopy((char*)new_e, (char*)old_e, sizeof(F_ellipse));
bcopy((char*)&swp_e, (char*)new_e, sizeof(F_ellipse));
/* but keep the next pointers unchanged */
swp_e.next = old_e->next;
old_e->next = new_e->next;
new_e->next = swp_e.next;
set_action_object(F_EDIT, O_ELLIPSE);
redisplay_ellipses(new_e, old_e);
break;
case O_TXT:
new_t = saved_objects.texts;
old_t = saved_objects.texts->next;
/* account for depths */
remove_depth(O_TXT, old_t->depth);
add_depth(O_TXT, new_t->depth);
/* swap old with new */
bcopy((char*)old_t, (char*)&swp_t, sizeof(F_text));
bcopy((char*)new_t, (char*)old_t, sizeof(F_text));
bcopy((char*)&swp_t, (char*)new_t, sizeof(F_text));
/* but keep the next pointers unchanged */
swp_t.next = old_t->next;
old_t->next = new_t->next;
new_t->next = swp_t.next;
set_action_object(F_EDIT, O_TXT);
redisplay_texts(new_t, old_t);
break;
case O_SPLINE:
new_s = saved_objects.splines;
old_s = saved_objects.splines->next;
/* account for depths */
remove_depth(O_SPLINE, old_s->depth);
add_depth(O_SPLINE, new_s->depth);
/* swap old with new */
bcopy((char*)old_s, (char*)&swp_s, sizeof(F_spline));
bcopy((char*)new_s, (char*)old_s, sizeof(F_spline));
bcopy((char*)&swp_s, (char*)new_s, sizeof(F_spline));
/* but keep the next pointers unchanged */
swp_s.next = old_s->next;
old_s->next = new_s->next;
new_s->next = swp_s.next;
set_action_object(F_EDIT, O_SPLINE);
redisplay_splines(new_s, old_s);
break;
case O_ARC:
new_a = saved_objects.arcs;
old_a = saved_objects.arcs->next;
/* account for depths */
remove_depth(O_ARC, old_a->depth);
add_depth(O_ARC, new_a->depth);
/* swap old with new */
bcopy((char*)old_a, (char*)&swp_a, sizeof(F_arc));
bcopy((char*)new_a, (char*)old_a, sizeof(F_arc));
bcopy((char*)&swp_a, (char*)new_a, sizeof(F_arc));
/* but keep the next pointers unchanged */
swp_a.next = old_a->next;
old_a->next = new_a->next;
new_a->next = swp_a.next;
set_action_object(F_EDIT, O_ARC);
redisplay_arcs(new_a, old_a);
break;
case O_COMPOUND:
new_c = saved_objects.compounds;
old_c = saved_objects.compounds->next;
/* account for depths */
remove_compound_depth(old_c);
add_compound_depth(new_c);
/* swap old with new */
bcopy((char*)old_c, (char*)&swp_c, sizeof(F_compound));
bcopy((char*)new_c, (char*)old_c, sizeof(F_compound));
bcopy((char*)&swp_c, (char*)new_c, sizeof(F_compound));
/* but keep the next pointers unchanged */
swp_c.next = old_c->next;
old_c->next = new_c->next;
new_c->next = swp_c.next;
set_action_object(F_EDIT, O_COMPOUND);
redisplay_compounds(new_c, old_c);
break;
case O_FIGURE:
/* swap saved figure comments with current */
swp_comm = objects.comments;
objects.comments = saved_objects.comments;
saved_objects.comments = swp_comm;
set_action_object(F_EDIT, O_FIGURE);
break;
case O_ALL_OBJECT:
swp_c = objects;
objects = saved_objects;
saved_objects = swp_c;
new_c = &objects;
old_c = &saved_objects;
/* account for depths */
remove_compound_depth(old_c);
add_compound_depth(new_c);
set_action_object(F_EDIT, O_ALL_OBJECT);
set_modifiedflag();
redisplay_zoomed_region(0, 0, BACKX(CANVAS_WD), BACKY(CANVAS_HT));
break;
}
}
void
toggle_open_closed_spline(F_spline *spline, F_point *previous_point, F_point *selected_point)
{
F_point *last_pt;
F_sfactor *last_sfactor, *previous_sfactor, *selected_sfactor;
if (spline->points->next == NULL || spline->points->next->next == NULL) {
put_msg("Not enough points for a spline");
beep();
return; /* less than 3 points - don't close the spline */
}
last_pt = last_point(spline->points);
last_sfactor = search_sfactor(spline, last_pt);
if (previous_point == NULL)
{
previous_sfactor = NULL;
selected_sfactor = spline->sfactors;
}
else
{
previous_sfactor = search_sfactor(spline, previous_point);
selected_sfactor = previous_sfactor->next;
set_last_tension(selected_sfactor->s, previous_sfactor->s);
}
draw_spline(spline, ERASE);
if (closed_spline(spline))
{
if (spline->points != selected_point)
{
last_pt->next = spline->points;
last_sfactor->next = spline->sfactors;
previous_point->next = NULL;
previous_sfactor->next = NULL;
previous_sfactor->s = S_SPLINE_ANGULAR;
spline->points = selected_point;
spline->sfactors = selected_sfactor;
}
else
{
last_sfactor->s = S_SPLINE_ANGULAR;
}
spline->sfactors->s = S_SPLINE_ANGULAR;
spline->type = (x_spline(spline)) ? T_OPEN_XSPLINE :
(int_spline(spline)) ? T_OPEN_INTERP : T_OPEN_APPROX;
clean_up();
}
else
{
int type_tmp;
double s_tmp;
if(int_spline(spline))
{
s_tmp = S_SPLINE_INTERP;
type_tmp = T_CLOSED_INTERP;
}
else
if (x_spline(spline))
{
s_tmp = S_SPLINE_INTERP;
type_tmp = T_CLOSED_XSPLINE;
}
else
{
s_tmp = S_SPLINE_APPROX;
type_tmp = T_CLOSED_APPROX;
}
spline->sfactors->s = last_sfactor->s = s_tmp;
spline->type = type_tmp;
clean_up();
set_last_arrows(spline->for_arrow, spline->back_arrow);
spline->back_arrow = spline->for_arrow = NULL;
}
draw_spline(spline, PAINT);
set_action_object(F_OPEN_CLOSE, O_SPLINE);
set_last_selectedpoint(spline->points);
set_last_prevpoint(NULL);
set_latestspline(spline);
set_modifiedflag();
}
void
spline_line(F_spline *s)
{
F_line *l;
F_point *tmppoint;
/* Now we turn s into a line */
if ((l = create_line()) == NULL)
return;
if (open_spline(s)) {
l->type = T_POLYLINE;
l->points = s->points;
} else {
l->type = T_POLYGON;
if ((l->points = create_point())==NULL)
return;
tmppoint = last_point(s->points);
l->points->x = tmppoint->x;
l->points->y = tmppoint->y;
l->points->next = copy_points(s->points);
}
l->style = s->style;
l->thickness = s->thickness;
l->pen_color = s->pen_color;
l->fill_color = s->fill_color;
l->depth = s->depth;
l->style_val = s->style_val;
l->cap_style = s->cap_style;
l->join_style = cur_joinstyle;
l->pen_style = s->pen_style;
l->radius = DEFAULT;
l->fill_style = s->fill_style;
if (s->for_arrow) {
l->for_arrow = create_arrow();
l->for_arrow->type = s->for_arrow->type;
l->for_arrow->style = s->for_arrow->style;
l->for_arrow->thickness = s->for_arrow->thickness;
l->for_arrow->wd = s->for_arrow->wd;
l->for_arrow->ht = s->for_arrow->ht;
} else {
l->for_arrow = NULL;
}
if (s->back_arrow) {
l->back_arrow = create_arrow();
l->back_arrow->type = s->back_arrow->type;
l->back_arrow->style = s->back_arrow->style;
l->back_arrow->thickness = s->back_arrow->thickness;
l->back_arrow->wd = s->back_arrow->wd;
l->back_arrow->ht = s->back_arrow->ht;
} else {
l->back_arrow = NULL;
}
/* now we have finished creating the line, we can get rid of the spline */
delete_spline(s);
/* and put in the new line */
mask_toggle_linemarker(l);
list_add_line(&objects.lines, l);
redisplay_line(l);
set_action_object(F_CONVERT, O_SPLINE);
set_latestline(l);
set_modifiedflag();
return;
}
void
line_spline(F_line *l, int type_value)
{
F_spline *s;
if (num_points(l->points) < CLOSED_SPLINE_MIN_NUM_POINTS) {
put_msg("Not enough points for a spline");
beep();
return;
}
if ((s = create_spline()) == NULL)
return;
s->type = type_value;
if (l->type == T_POLYGON)
s->points = copy_points(l->points->next);
else
s->points = copy_points(l->points);
s->style = l->style;
s->thickness = l->thickness;
s->pen_color = l->pen_color;
s->fill_color = l->fill_color;
s->depth = l->depth;
s->style_val = l->style_val;
s->cap_style = l->cap_style;
s->pen_style = l->pen_style;
s->fill_style = l->fill_style;
s->sfactors = NULL;
s->next = NULL;
if (l->for_arrow) {
s->for_arrow = create_arrow();
s->for_arrow->type = l->for_arrow->type;
s->for_arrow->style = l->for_arrow->style;
s->for_arrow->thickness = l->for_arrow->thickness;
s->for_arrow->wd = l->for_arrow->wd;
s->for_arrow->ht = l->for_arrow->ht;
} else {
s->for_arrow = NULL;
}
if (l->back_arrow) {
s->back_arrow = create_arrow();
s->back_arrow->type = l->back_arrow->type;
s->back_arrow->style = l->back_arrow->style;
s->back_arrow->thickness = l->back_arrow->thickness;
s->back_arrow->wd = l->back_arrow->wd;
s->back_arrow->ht = l->back_arrow->ht;
} else {
s->back_arrow = NULL;
}
/* A spline must have an s parameter for each point */
if (!make_sfactors(s)) {
free_spline(&s);
return;
}
/* Get rid of the line and draw the new spline */
delete_line(l);
/* now put back the new spline */
mask_toggle_splinemarker(s);
list_add_spline(&objects.splines, s);
redisplay_spline(s);
set_action_object(F_CONVERT, O_POLYLINE);
set_latestspline(s);
set_modifiedflag();
}
