From: Mario Haustein <mario.haustein@hrz.tu-chemnitz.de>
Date: Sun, 2 Feb 2025 17:37:11 +0100
Origin: upstream, https://sourceforge.net/p/mcj/xfig/ci/92a8262
Forwarded: not-needed
Bug: https://sourceforge.net/p/mcj/tickets/194/
Bug-Debian: https://bugs.debian.org/1098137
Last-Update: 2025-09-05
Subject: Fix prototypes for manipulation callbacks

--- a/src/e_addpt.c
+++ b/src/e_addpt.c
@@ -17,6 +17,7 @@
 
 #include "e_addpt.h"
 
+#include <stdarg.h>
 #include <stddef.h>
 
 #include "resources.h"
@@ -38,7 +39,7 @@
 #include "w_modepanel.h"
 
 
-static void	init_point_adding(F_line *p, int type, int x, int y, int px, int py);
+static void	init_point_adding(void *obj, int type, int x, int y, ...);
 static void	fix_linepoint_adding(int x, int y, unsigned int shift);
 static void	fix_splinepoint_adding(int x, int y, unsigned int shift);
 static void	init_linepointadding(int px, int py);
@@ -65,23 +66,32 @@ point_adding_selected(void)
 }
 
 static void
-init_point_adding(F_line *p, int type, int x, int y, int px, int py)
+init_point_adding(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
 	(void)x;
 	(void)y;
 
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     set_action_on();
     set_mousefun("place new point", "", "cancel", LOC_OBJ, LOC_OBJ, LOC_OBJ);
     draw_mousefun_canvas();
     set_cursor(null_cursor);
     switch (type) {
     case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	/* the search routine will ensure that we don't have a box */
 	init_linepointadding(px, py);
 	break;
     case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	init_splinepointadding(px, py);
 	break;
     default:
--- a/src/e_align.c
+++ b/src/e_align.c
@@ -51,7 +51,7 @@ static Boolean	pos_spline(F_spline *s, i
 static Boolean	pos_text(F_text *t, int *min, int *size, int dir);
 static Boolean	pos_compound(F_compound *c, int *min, int *size, int dir);
 
-static void	init_align(F_line *p, int type, int x, int y, int px, int py);
+static void	init_align(void *obj, int type, int x, int y, ...);
 static void	init_align_canvas(int x, int y, unsigned int shift);
 static void	align_arc(void);
 static void	align_ellipse(void);
@@ -139,16 +139,14 @@ init_align_canvas(int x, int y, unsigned
 }
 
 static void
-init_align(F_line *p, int type, int x, int y, int px, int py)
+init_align(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
-	(void)px;
-	(void)py;
 
     if (type != O_COMPOUND)
 	return;
-    cur_c = (F_compound *) p;
+    cur_c = (F_compound *) obj;
     toggle_compoundmarker(cur_c);
     draw_compoundelements(cur_c, ERASE);
     old_c = copy_compound(cur_c);
--- a/src/e_arrow.c
+++ b/src/e_arrow.c
@@ -18,6 +18,7 @@
 
 #include "e_arrow.h"
 
+#include <stdarg.h>
 #include <stdlib.h>
 
 #include "resources.h"
@@ -34,10 +35,8 @@
 #include "w_mousefun.h"
 
 
-static void	add_arrow_head(F_line *obj, int type, int x, int y,
-				F_point *p, F_point *q, int pnum);
-static void	delete_arrow_head(F_line *obj, int type, int x, int y,
-				F_point *p, F_point *q, int pnum);
+static void	add_arrow_head(void *obj, int type, int x, int y, ...);
+static void	delete_arrow_head(void *obj, int type, int x, int y, ...);
 static void	add_linearrow(F_line *line, F_point *prev_point,
 				F_point *selected_point);
 static void	add_arcarrow(F_arc *arc, int point_num);
@@ -63,12 +62,22 @@ arrow_head_selected(void)
 }
 
 static void
-add_arrow_head(F_line *obj, int type, int x, int y, F_point *p, F_point *q,
-		int pnum)
+add_arrow_head(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+	va_list args;
+	F_point *p;
+	F_point *q;
+	int pnum;
+
+	va_start(args, y);
+	p = va_arg(args, F_point*);
+	q = va_arg(args, F_point*);
+	pnum = va_arg(args, int);
+	va_end(args);
+
 	switch (type) {
 	case O_POLYLINE:
 		cur_l = (F_line *) obj;
@@ -86,12 +95,22 @@ add_arrow_head(F_line *obj, int type, in
 }
 
 static void
-delete_arrow_head(F_line *obj, int type, int x, int y, F_point *p, F_point *q,
-		int pnum)
+delete_arrow_head(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+	F_point *p;
+	F_point *q;
+	int pnum;
+
+	va_list args;
+	va_start(args, y);
+	p = va_arg(args, F_point*);
+	q = va_arg(args, F_point*);
+	pnum = va_arg(args, int);
+	va_end(args);
+
 	switch (type) {
 	case O_POLYLINE:
 		cur_l = (F_line *) obj;
--- a/src/e_break.c
+++ b/src/e_break.c
@@ -30,12 +30,9 @@
 #include "w_mousefun.h"
 
 
-static void	init_break(F_line *p, int type, int x, int y, int px, int py,
-				int loc_tag);
-static void	init_break_only(F_line *p, int type, int x, int y, int px,
-				int py);
-static void	init_break_tag(F_line *p, int type, int x, int y, int px,
-				int py);
+static void	init_break(void *obj, int type, int loc_tag);
+static void	init_break_only(void *obj, int type, int x, int y, ...);
+static void	init_break_tag(void *obj, int type, int x, int y, ...);
 
 
 
@@ -56,29 +53,28 @@ break_selected(void)
 }
 
 static void
-init_break_only(F_line *p, int type, int x, int y, int px, int py)
+init_break_only(void *obj, int type, int x, int y, ...)
 {
-    init_break(p, type, x, y, px, py, 0);
+	(void)x;
+	(void)y;
+    init_break(obj, type, 0);
 }
 
 static void
-init_break_tag(F_line *p, int type, int x, int y, int px, int py)
+init_break_tag(void *obj, int type, int x, int y, ...)
 {
-    init_break(p, type, x, y, px, py, 1);
+	(void)x;
+	(void)y;
+    init_break(obj, type, 1);
 }
 
 static void
-init_break(F_line *p, int type, int x, int y, int px, int py, int loc_tag)
+init_break(void *obj, int type, int loc_tag)
 {
-	(void)x;
-	(void)y;
-	(void)px;
-	(void)py;
-
     if (type != O_COMPOUND)
 	return;
 
-    cur_c = (F_compound *) p;
+    cur_c = (F_compound *)obj;
     mask_toggle_compoundmarker(cur_c);
     clean_up();
     list_delete_compound(&objects.compounds, cur_c);
--- a/src/e_chop.c
+++ b/src/e_chop.c
@@ -44,8 +44,8 @@
 #include "w_snap.h"
 #include "xfig_math.h"
 
-static void select_axe_object();
-static void select_log_object();
+static void select_axe_object(void *obj, int type, int x, int y, ...);
+static void select_log_object(void *obj, int type, int x, int y, ...);
 static void clear_axe_objects(int x, int y, unsigned shift);
 
 typedef struct {
@@ -107,9 +107,9 @@ chop_selected(void)
 }
 
 static void
-select_axe_object(void *obj, int type, int x, int y, F_point *p, F_point * q)
+select_axe_object(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)p; (void)q;
+	(void)x; (void)y;
 
   int i;
 
@@ -826,10 +826,8 @@ chop_ellipse(F_ellipse * e, int x, int y
 }
 
 static void
-select_log_object(void *obj, int type, int x, int y, F_point *p, F_point *q)
+select_log_object(void *obj, int type, int x, int y, ...)
 {
-	(void)p;
-	(void)q;
   Boolean rc;
 
   switch(type) {
--- a/src/e_compound.c
+++ b/src/e_compound.c
@@ -66,31 +66,25 @@ static void	popup_close_compound (void);
 
 
 static void
-init_open_compound(F_compound *c, int type, int x, int y, int px, int py)
+init_open_compound(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
-	(void)px;
-	(void)py;
 
     if (type != O_COMPOUND)
 	return;
-    open_this_compound(c, False);
+    open_this_compound((F_compound*)obj, False);
 }
 
 static void
-init_open_compound_vis(F_compound *c, int type, int x, int y, int px, int py,
-		int loc_tag)
+init_open_compound_vis(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
-	(void)px;
-	(void)py;
-	(void)loc_tag;
 
     if (type != O_COMPOUND)
 	return;
-    open_this_compound(c, True);
+    open_this_compound((F_compound*)obj, True);
 }
 
 void
--- a/src/e_convert.c
+++ b/src/e_convert.c
@@ -19,6 +19,7 @@
 
 #include "e_convert.h"
 
+#include <stdarg.h>
 #include <stdlib.h>
 
 #include "resources.h"
@@ -41,10 +42,8 @@
 #include "w_msgpanel.h"
 
 
-static void	init_convert_line_spline(F_line *p, int type, int x, int y,
-					int px, int py);
-static void	init_convert_open_closed(F_line *obj, int type, int x, int y,
-					F_point *p, F_point *q);
+static void	init_convert_line_spline(void *obj, int type, int x, int y, ...);
+static void	init_convert_open_closed(void *obj, int type, int x, int y, ...);
 
 
 
@@ -65,12 +64,20 @@ convert_selected(void)
 }
 
 static void
-init_convert_open_closed(F_line *obj, int type, int x, int y, F_point *p,
-			F_point *q)
+init_convert_open_closed(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+    va_list args;
+    F_point *p;
+    F_point *q;
+
+    va_start(args, y);
+    p = va_arg(args, F_point*);
+    q = va_arg(args, F_point*);
+    va_end(args);
+
     switch (type) {
     case O_POLYLINE:
       cur_l = (F_line *) obj;
@@ -86,15 +93,15 @@ init_convert_open_closed(F_line *obj, in
 }
 
 static void
-init_convert_line_spline(F_line *p, int type, int x, int y, int px, int py)
+init_convert_line_spline(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
 
     static int flag = 0;
 
     switch (type) {
     case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	/* the search routine will ensure that we don't have a box */
 	if (cur_l->type == T_POLYLINE || cur_l->type == T_POLYGON) {
 	    line_spline(cur_l, cur_l->type == T_POLYGON ?
@@ -105,7 +112,7 @@ init_convert_line_spline(F_line *p, int
 	}
 	break;
     case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	flag = (cur_s->type==T_OPEN_INTERP) || (cur_s->type==T_CLOSED_INTERP);
 	spline_line(cur_s);
 	break;
--- a/src/e_copy.c
+++ b/src/e_copy.c
@@ -39,12 +39,10 @@
 #include "w_msgpanel.h"
 
 /* local routine declarations */
-static void	init_copy(F_line *p, int type, int x, int y, int px, int py);
-static void	init_arb_copy(F_line *p, int type, int x, int y, int px,int py);
-static void	init_constrained_copy(F_line *p, int type, int x, int y, int px,
-					int py);
-static void	init_copy_to_scrap(F_line *p, int type, int x, int y, int px,
-					int py);
+static void	init_copy(void *obj, int type, int x, int y, int px, int py);
+static void	init_arb_copy(void *obj, int type, int x, int y, ...);
+static void	init_constrained_copy(void *obj, int type, int x, int y, ...);
+static void	init_copy_to_scrap(void *obj, int type, int x, int y, ...);
 
 
 
@@ -68,64 +66,82 @@ copy_selected(void)
 }
 
 static void
-init_arb_copy(F_line *p, int type, int x, int y, int px, int py)
+init_arb_copy(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     constrained = MOVE_ARB;
-    init_copy(p, type, x, y, px, py);
+    init_copy(obj, type, x, y, px, py);
     set_mousefun("place object", "array placement", "cancel",
 		LOC_OBJ, LOC_OBJ, LOC_OBJ);
     draw_mousefun_canvas();
 }
 
 static void
-init_constrained_copy(F_line *p, int type, int x, int y, int px, int py)
+init_constrained_copy(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     constrained = MOVE_HORIZ_VERT;
-    init_copy(p, type, x, y, px, py);
+    init_copy(obj, type, x, y, px, py);
     set_mousefun("place object", "array placement", "cancel",
 		LOC_OBJ, LOC_OBJ, LOC_OBJ);
     draw_mousefun_canvas();
 }
 
 static void
-init_copy(F_line *p, int type, int x, int y, int px, int py)
+init_copy(void *obj, int type, int x, int y, int px, int py)
 {
     /* turn off all markers */
     update_markers(0);
     switch (type) {
     case O_COMPOUND:
 	set_cursor(null_cursor);
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *) obj;
 	new_c = copy_compound(cur_c);
 	init_compounddragging(new_c, px, py);
 	break;
     case O_POLYLINE:
 	set_cursor(null_cursor);
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	new_l = copy_line(cur_l);
 	init_linedragging(new_l, px, py);
 	break;
     case O_TXT:
 	set_cursor(null_cursor);
-	cur_t = (F_text *) p;
+	cur_t = (F_text *) obj;
 	new_t = copy_text(cur_t);
 	init_textdragging(new_t, x, y);
 	break;
     case O_ELLIPSE:
 	set_cursor(null_cursor);
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *) obj;
 	new_e = copy_ellipse(cur_e);
 	init_ellipsedragging(new_e, px, py);
 	break;
     case O_ARC:
 	set_cursor(null_cursor);
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *) obj;
 	new_a = copy_arc(cur_a);
 	init_arcdragging(new_a, px, py);
 	break;
     case O_SPLINE:
 	set_cursor(null_cursor);
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	new_s = copy_spline(cur_s);
 	init_splinedragging(new_s, px, py);
 	break;
@@ -135,9 +151,9 @@ init_copy(F_line *p, int type, int x, in
 }
 
 static void
-init_copy_to_scrap(F_line *p, int type, int x, int y, int px, int py)
+init_copy_to_scrap(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
     FILE	   *fp;
     FILE	   *open_cut_file(void);
 
@@ -149,27 +165,27 @@ init_copy_to_scrap(F_line *p, int type,
 
     switch (type) {
     case O_COMPOUND:
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *)obj;
 	write_compound(fp, cur_c);
 	break;
     case O_ARC:
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *)obj;
 	write_arc(fp, cur_a);
 	break;
     case O_ELLIPSE:
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *)obj;
 	write_ellipse(fp, cur_e);
 	break;
     case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *)obj;
 	write_line(fp, cur_l);
 	break;
     case O_TXT:
-	cur_t = (F_text *) p;
+	cur_t = (F_text *)obj;
 	write_text(fp, cur_t);
 	break;
     case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *)obj;
 	write_spline(fp, cur_s);
 	break;
     default:
--- a/src/e_delete.c
+++ b/src/e_delete.c
@@ -52,11 +52,11 @@
 #include "xfig_math.h"
 
 
-static void	init_delete(F_line *p, int type, int x, int y, int px, int py);
+static void	init_delete(void *obj, int type, int x, int y, ...);
 static void	init_delete_region(int x, int y, unsigned int shift);
 static void	delete_region(int x, int y, unsigned int shift);
 static void	cancel_delete_region(int x, int y, unsigned int shift);
-static void	init_delete_to_scrap(F_line *p, int type, int x, int y, int px, int py);
+static void	init_delete_to_scrap(void *obj, int type, int x, int y, ...);
 
 
 
@@ -78,38 +78,38 @@ delete_selected(void)
 }
 
 static void
-init_delete(F_line *p, int type, int x, int y, int px, int py)
+init_delete(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
 
     switch (type) {
     case O_COMPOUND:
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *) obj;
 	delete_compound(cur_c);
 	redisplay_compound(cur_c);
 	break;
     case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	delete_line(cur_l);
 	redisplay_line(cur_l);
 	break;
     case O_TXT:
-	cur_t = (F_text *) p;
+	cur_t = (F_text *) obj;
 	delete_text(cur_t);
 	redisplay_text(cur_t);
 	break;
     case O_ELLIPSE:
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *) obj;
 	delete_ellipse(cur_e);
 	redisplay_ellipse(cur_e);
 	break;
     case O_ARC:
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *) obj;
 	delete_arc(cur_a);
 	redisplay_arc(cur_a);
 	break;
     case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	delete_spline(cur_s);
 	redisplay_spline(cur_s);
 	break;
@@ -184,9 +184,9 @@ delete_region(int x, int y, unsigned int
 }
 
 static void
-init_delete_to_scrap(F_line *p, int type, int x, int y, int px, int py)
+init_delete_to_scrap(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
     FILE	   *fp;
     FILE	   *open_cut_file(void);
 
@@ -198,37 +198,37 @@ init_delete_to_scrap(F_line *p, int type
 
     switch (type) {
     case O_COMPOUND:
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *)obj;
 	write_compound(fp, cur_c);
 	delete_compound(cur_c);
 	redisplay_compound(cur_c);
 	break;
     case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *)obj;
 	write_line(fp, cur_l);
 	delete_line(cur_l);
 	redisplay_line(cur_l);
 	break;
     case O_TXT:
-	cur_t = (F_text *) p;
+	cur_t = (F_text *)obj;
 	write_text(fp, cur_t);
 	delete_text(cur_t);
 	redisplay_text(cur_t);
 	break;
     case O_ELLIPSE:
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *)obj;
 	write_ellipse(fp, cur_e);
 	delete_ellipse(cur_e);
 	redisplay_ellipse(cur_e);
 	break;
     case O_ARC:
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *)obj;
 	write_arc(fp, cur_a);
 	delete_arc(cur_a);
 	redisplay_arc(cur_a);
 	break;
     case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *)obj;
 	write_spline(fp, cur_s);
 	delete_spline(cur_s);
 	redisplay_spline(cur_s);
--- a/src/e_deletept.c
+++ b/src/e_deletept.c
@@ -18,6 +18,7 @@
 
 #include "e_deletept.h"
 
+#include <stdarg.h>
 #include <stddef.h>
 
 #include "resources.h"
@@ -37,8 +38,7 @@
 #include "w_msgpanel.h"
 
 
-static void	init_delete_point(F_line *obj, int type, int x, int y,
-					F_point *p, F_point *q);
+static void	init_delete_point(void *obj, int type, int x, int y, ...);
 
 
 void
@@ -57,12 +57,21 @@ delete_point_selected(void)
 }
 
 static void
-init_delete_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q)
+init_delete_point(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
+
+    va_list args;
+    F_point *p;
+    F_point *q;
     int		    n;
 
+    va_start(args, y);
+    p = va_arg(args, F_point*);
+    q = va_arg(args, F_point*);
+    va_end(args);
+
     switch (type) {
     case O_POLYLINE:
 	cur_l = (F_line *) obj;
--- a/src/e_edit.c
+++ b/src/e_edit.c
@@ -27,6 +27,7 @@
 
 #include <errno.h>
 #include <math.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -678,8 +679,7 @@ void get_generic_arrows(F_line *x)
 	}
 }
 
-static void	edit_spline_point(F_spline *spline, int type, int x, int y,
-				F_point *previous_point, F_point *the_point);
+static void	edit_spline_point(void *obj, int type, int x, int y, ...);
 static void	edit_figure_comments(int x, int y, unsigned int shift);
 
 void edit_item_selected(void)
@@ -703,7 +703,7 @@ void edit_item_selected(void)
    editing of the whole figure comments (shift=0)
 */
 
-static void	popup_show_comments(F_line *p, int type, int x, int y);
+static void	popup_show_comments(void *obj, int type, int x, int y, ...);
 
 static void				/* Shift Key Status from XEvent */
 edit_figure_comments(int x, int y, unsigned int shift)
@@ -721,7 +721,7 @@ edit_figure_comments(int x, int y, unsig
 }
 
 static void
-popup_show_comments(F_line *p, int type, int x, int y)
+popup_show_comments(void *obj, int type, int x, int y, ...)
 {
 	Widget		form;
 	static Boolean	actions_added = False;
@@ -735,27 +735,27 @@ popup_show_comments(F_line *p, int type,
 
 	switch (type) {
 	case O_ARC:
-		a = (F_arc *)p;
+		a = (F_arc *)obj;
 		comments = a->comments;
 		break;
 	case O_COMPOUND:
-		c = (F_compound *)p;
+		c = (F_compound *)obj;
 		comments = c->comments;
 		break;
 	case O_ELLIPSE:
-		e = (F_ellipse *)p;
+		e = (F_ellipse *)obj;
 		comments = e->comments;
 		break;
 	case O_POLYLINE:
-		l = (F_line *)p;
+		l = (F_line *)obj;
 		comments = l->comments;
 		break;
 	case O_SPLINE:
-		s = (F_spline *)p;
+		s = (F_spline *)obj;
 		comments = s->comments;
 		break;
 	case O_TXT:
-		t = (F_text *)p;
+		t = (F_text *)obj;
 		comments = t->comments;
 		break;
 	} /* switch */
@@ -818,7 +818,7 @@ popdown_comments(void)
 }
 
 void
-edit_item(void *p, int type, int x, int y)
+edit_item(void *obj, int type, int x, int y, ...)
 {
 	XtWidgetGeometry	xtgeom,comp;
 	int			llx, lly, urx, ury;
@@ -855,37 +855,37 @@ edit_item(void *p, int type, int x, int
 	/* get the bounds of the object to position the popup away from it */
 	switch (type) {
 	case O_POLYLINE:
-		line_bound((F_line *)p, &llx, &lly, &urx, &ury);
-		make_window_line((F_line *)p);
+		line_bound((F_line *)obj, &llx, &lly, &urx, &ury);
+		make_window_line((F_line *)obj);
 		break;
 	case O_TXT:
-		text_bound((F_text *)p, &llx, &lly, &urx, &ury);
-		make_window_text((F_text *)p);
+		text_bound((F_text *)obj, &llx, &lly, &urx, &ury);
+		make_window_text((F_text *)obj);
 		break;
 	case O_ELLIPSE:
-		ellipse_bound((F_ellipse *)p, &llx, &lly, &urx, &ury);
-		make_window_ellipse((F_ellipse *)p);
+		ellipse_bound((F_ellipse *)obj, &llx, &lly, &urx, &ury);
+		make_window_ellipse((F_ellipse *)obj);
 		break;
 	case O_ARC:
-		arc_bound((F_arc *)p, &llx, &lly, &urx, &ury);
-		make_window_arc((F_arc *)p);
+		arc_bound((F_arc *)obj, &llx, &lly, &urx, &ury);
+		make_window_arc((F_arc *)obj);
 		break;
 	case O_SPLINE:
-		spline_bound((F_spline *)p, &llx, &lly, &urx, &ury);
-		make_window_spline((F_spline *)p);
+		spline_bound((F_spline *)obj, &llx, &lly, &urx, &ury);
+		make_window_spline((F_spline *)obj);
 		break;
 	case O_COMPOUND:
 		/* make compound_bound() get boundaries in the current point
 		   positioning mode, do not create a tight bounding box */
 		anypointposn = 0;
-		compound_bound((F_compound *) p, &llx, &lly, &urx, &ury);
+		compound_bound((F_compound *) obj, &llx, &lly, &urx, &ury);
 		/* turn on the point positioning indicator since it is used
 		   for editing compound */
 		update_indpanel(I_MIN2);
-		make_window_compound((F_compound *)p);
+		make_window_compound((F_compound *)obj);
 		break;
 	case O_FIGURE:
-		compound_bound((F_compound *)p, &llx, &lly, &urx, &ury);
+		compound_bound((F_compound *)obj, &llx, &lly, &urx, &ury);
 		make_window_figure();
 		break;
 	}
@@ -968,12 +968,21 @@ reread_picfile(Widget panel_local, XtPoi
 
 
 static void
-edit_spline_point(F_spline *spline, int type, int x, int y,
-		F_point *previous_point, F_point *the_point)
+edit_spline_point(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+	va_list args;
+	F_point *previous_point;
+	F_point *the_point;
+	F_spline *spline = obj;
+
+	va_start(args, y);
+	previous_point = va_arg(args, F_point*);
+	the_point = va_arg(args, F_point*);
+	va_end(args);
+
 	if (type!=O_SPLINE) {
 		put_msg("Only spline points can be edited");
 		return;
--- a/src/e_edit.h
+++ b/src/e_edit.h
@@ -34,7 +34,7 @@ extern Widget	color_selection_panel(char
 			Widget *button, Widget *popup,
 			int color, XtCallbackProc callback);
 extern void	color_select(Widget w, Color color);
-extern void	edit_item (void *p, int type, int x, int y);
+extern void	edit_item (void *p, int type, int x, int y, ...);
 extern void	edit_item_selected (void);
 extern void	push_apply_button (void);
 
--- a/src/e_flip.c
+++ b/src/e_flip.c
@@ -19,6 +19,7 @@
 #include "e_flip.h"
 
 #include <math.h>
+#include <stdarg.h>
 #include <stddef.h>
 
 #include "resources.h"
@@ -49,8 +50,8 @@ int		setanchor_y;
 static int	flip_axis;
 static int	copy;
 
-static void	init_flip(F_line *p, int type, int x, int y, int px, int py);
-static void	init_copynflip(F_line *p, int type, int x,int y, int px,int py);
+static void	init_flip(void *p, int type, int x, int y, ...);
+static void	init_copynflip(void *p, int type, int x, int y, ...);
 static void	set_unset_anchor(int x, int y, unsigned int shift);
 static void	init_fliparc(F_arc *old_a, int px, int py);
 static void	init_flipcompound(F_compound *old_c, int px, int py);
@@ -58,7 +59,7 @@ static void	init_flipellipse(F_ellipse *
 static void	init_flipline(F_line *old_l, int px, int py);
 static void	init_flipspline(F_spline *old_s, int px, int py);
 static void	flip_selected(void);
-static void	flip_search(F_line *p, int type, int x, int y, int px, int py);
+static void	flip_search(void *obj, int type, int x, int y, int px, int py);
 static void	flip_arc (F_arc *a, int x, int y, int flip_axis);
 static void	flip_ellipse (F_ellipse *e, int x, int y, int flip_axis);
 static void	flip_line (F_line *l, int x, int y, int flip_axis);
@@ -139,52 +140,70 @@ set_unset_anchor(int x, int y, unsigned
 }
 
 static void
-init_flip(F_line *p, int type, int x, int y, int px, int py)
+init_flip(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     copy = 0;
     if (setanchor)
-	flip_search(p, type, x, y,setanchor_x,setanchor_y );
+	flip_search(obj, type, x, y,setanchor_x,setanchor_y );
 	/* remember rotation center, e.g for multiple rotation*/
     else
-	flip_search(p, type, x, y, px, py);
+	flip_search(obj, type, x, y, px, py);
 }
 
 static void
-init_copynflip(F_line *p, int type, int x, int y, int px, int py)
+init_copynflip(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     copy = 1;
     if (setanchor)
-	flip_search(p, type, x, y,setanchor_x,setanchor_y );
+	flip_search(obj, type, x, y,setanchor_x,setanchor_y );
 	/* remember rotation center, e.g for multiple rotation*/
     else
-	flip_search(p, type, x, y, px, py);
+	flip_search(obj, type, x, y, px, py);
 }
 
 static void
-flip_search(F_line *p, int type, int x, int y, int px, int py)
+flip_search(void *obj, int type, int x, int y, int px, int py)
 {
 	(void)x;
 	(void)y;
 
     switch (type) {
     case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	init_flipline(cur_l, px, py);
 	break;
     case O_ARC:
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *) obj;
 	init_fliparc(cur_a, px, py);
 	break;
     case O_ELLIPSE:
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *) obj;
 	init_flipellipse(cur_e, px, py);
 	break;
     case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	init_flipspline(cur_s, px, py);
 	break;
     case O_COMPOUND:
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *) obj;
 	init_flipcompound(cur_c, px, py);
 	break;
     default:
--- a/src/e_glue.c
+++ b/src/e_glue.c
@@ -45,7 +45,7 @@ static void	create_compoundobject(int x,
 static void	cancel_tag_region(int x, int y, unsigned int shift);
 static void	init_tag_region(int x, int y, unsigned int shift);
 static void	tag_region(int x, int y, unsigned int shift);
-static void	tag_object(F_line *p, int type, int x, int y, int px, int py);
+static void	tag_object(void *obj, int type, int x, int y, ...);
 static void	get_arc(F_arc **list);
 static void	sel_arc(int xmin, int ymin, int xmax, int ymax);
 static void	get_compound(F_compound **list);
@@ -77,38 +77,38 @@ compound_selected(void)
 }
 
 static void
-tag_object(F_line *p, int type, int x, int y, int px, int py)
+tag_object(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
 
     switch (type) {
     case O_COMPOUND:
-        cur_c = (F_compound *) p;
+        cur_c = (F_compound *) obj;
         toggle_compoundhighlight(cur_c);
 	cur_c->tagged = 1 - cur_c->tagged;
         break;
     case O_POLYLINE:
-        cur_l = (F_line *) p;
+        cur_l = (F_line *) obj;
         toggle_linehighlight(cur_l);
 	cur_l->tagged = 1 - cur_l->tagged;
         break;
     case O_TXT:
-        cur_t = (F_text *) p;
+        cur_t = (F_text *) obj;
         toggle_texthighlight(cur_t);
 	cur_t->tagged = 1 - cur_t->tagged;
         break;
     case O_ELLIPSE:
-        cur_e = (F_ellipse *) p;
+        cur_e = (F_ellipse *) obj;
         toggle_ellipsehighlight(cur_e);
 	cur_e->tagged = 1 - cur_e->tagged;
         break;
     case O_ARC:
-        cur_a = (F_arc *) p;
+        cur_a = (F_arc *) obj;
         toggle_archighlight(cur_a);
 	cur_a->tagged = 1 - cur_a->tagged;
         break;
     case O_SPLINE:
-        cur_s = (F_spline *) p;
+        cur_s = (F_spline *) obj;
         toggle_splinehighlight(cur_s);
 	cur_s->tagged = 1 - cur_s->tagged;
         break;
--- a/src/e_joinsplit.c
+++ b/src/e_joinsplit.c
@@ -17,6 +17,7 @@
 
 #include "e_joinsplit.h"
 
+#include <stdarg.h>
 #include <stdlib.h>
 #include <X11/Intrinsic.h>	/* includes X11/Xlib.h */
 
@@ -41,9 +42,8 @@
 #include "w_msgpanel.h"
 
 
-static void	init_join(F_line *obj, int type, int x, int y, F_point *p,
-			F_point *q);
-static void	init_split(F_line *obj, int type, int x, int y, int px, int py);
+static void	init_join(void *obj, int type, int x, int y, ...);
+static void	init_split(void *obj, int type, int x, int y, ...);
 static void	join_lines(F_line *line, F_point *prev_point,
 			F_point *selected_point);
 static void	join_splines(F_spline *spline, F_point *prev_point,
@@ -51,10 +51,8 @@ static void	join_splines(F_spline *splin
 static void	split_line(int px, int py);
 static void	split_spline(int px, int py);
 static void	cancel_join(int x, int y, unsigned int shift);
-static void	join_line2(F_line *obj, int type, int x, int y, F_point *p,
-			F_point *q);
-static void	join_spline2(F_line *obj, int type, int x, int y, F_point *p,
-			F_point *q);
+static void	join_line2(void *obj, int type, int x, int y, ...);
+static void	join_spline2(void *obj, int type, int x, int y, ...);
 static Boolean	connect_line_points(F_line *line1, Boolean first1,
 			F_line *line2, Boolean first2, F_line *new_line);
 static Boolean	connect_spline_points(F_spline *spline1, Boolean first1,
@@ -90,11 +88,20 @@ join_split_selected(void)
 }
 
 static void
-init_join(F_line *obj, int type, int x, int y, F_point *p, F_point *q)
+init_join(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+    va_list args;
+    F_point *p;
+    F_point *q;
+
+    va_start(args, y);
+    p = va_arg(args, F_point*);
+    q = va_arg(args, F_point*);
+    va_end(args);
+
     switch (type) {
       case O_POLYLINE:
 	cur_l = (F_line *) obj;
@@ -110,11 +117,20 @@ init_join(F_line *obj, int type, int x,
 }
 
 static void
-init_split(F_line *obj, int type, int x, int y, int px, int py)
+init_split(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     switch (type) {
       case O_POLYLINE:
 	cur_l = (F_line *) obj;
@@ -227,13 +243,22 @@ cancel_join(int x, int y, unsigned int s
 }
 
 static void
-join_line2(F_line *obj, int type, int x, int y, F_point *p, F_point *q)
+join_line2(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
+
+	va_list args;
+	F_point *p;
+	F_point *q;
 	F_line	   *line;
 	F_point	   *lastp;
 
+	va_start(args, y);
+	p = va_arg(args, F_point*);
+	q = va_arg(args, F_point*);
+	va_end(args);
+
 	if (type != O_POLYLINE)
 		return;
 	/* only continue if the user has selected an end point */
@@ -276,19 +301,28 @@ join_line2(F_line *obj, int type, int x,
 }
 
 static void
-join_spline2(F_line *obj, int type, int x, int y, F_point *p, F_point *q)
+join_spline2(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
+
+	va_list args;
+	F_point *p;
+	F_point *q;
 	F_spline   *spline;
 
+	va_start(args, y);
+	p = va_arg(args, F_point*);
+	q = va_arg(args, F_point*);
+	va_end(args);
+
 	if (type != O_SPLINE)
 		return;
 	/* only continue if the user has selected an end point */
 	if (p != NULL && q->next != NULL)
 		return;
 	spline = (F_spline *) obj;
-	first2 = (q == obj->points);
+	first2 = (q == spline->points);
 	new_s = copy_spline(spline1);
 	/* if user clicked on both endpoints of a spline, make it a closed SPLINE */
 	if (spline == spline1) {
--- a/src/e_measure.c
+++ b/src/e_measure.c
@@ -40,9 +40,9 @@
 /* Measuring angles, lengths and areas */
 
 
-static void init_anglemeas_object(char *p, int type, int x, int y, F_point *pp, F_point *pq);
-static void init_anglemeas_object_m(char *p, int type, int x, int y, F_point *pp, F_point *pq);
-static void init_anglemeas_object_r(char *p, int type, int x, int y, F_point *pp, F_point *pq);
+static void init_anglemeas_object(void *p, int type, F_point *pq);
+static void init_anglemeas_object_m(void *p, int type, int x, int y, ...);
+static void init_anglemeas_object_r(void *p, int type, int x, int y, ...);
 static void init_anglemeas_threepoints(int px, int py, unsigned int shift);
 
 static void anglemeas_second(int x, int y, unsigned int shift);
@@ -55,14 +55,14 @@ static void anglemeas_arc(F_arc *a);
 static void angle_msg(double value, char *msgtext);
 static void angle_save(double value);
 
-static void init_lenmeas_object(char *p, int type, int x, int y, int px, int py);
-static void init_lenmeas_object_l(char *p, int type, int x, int y, int px, int py);
-static void init_lenmeas_object_m(char *p, int type, int x, int y, int px, int py);
+static void init_lenmeas_object(void *obj, int type);
+static void init_lenmeas_object_l(void *obj, int type, int x, int y, ...);
+static void init_lenmeas_object_m(void *obj, int type, int x, int y, ...);
 static void clear_lenmeas_memory(int x, int y, unsigned int shift);
 
-static void init_areameas_object(char *p, int type, int x, int y, int px, int py);
-static void init_areameas_object_l(char *p, int type, int x, int y, int px, int py);
-static void init_areameas_object_m(char *p, int type, int x, int y, int px, int py);
+static void init_areameas_object(void *obj, int type);
+static void init_areameas_object_l(void *obj, int type, int x, int y, ...);
+static void init_areameas_object_m(void *obj, int type, int x, int y, ...);
 static void clear_areameas_memory(int x, int y, unsigned int shift);
 
 static void freehand_line_nomsg(int x, int y);
@@ -122,33 +122,53 @@ angle_save(double value)
 /* OBJECT ANGLE MEASURING */
 
 static void
-init_anglemeas_object_m(char *p, int type, int x, int y, F_point *pp, F_point *pq)
+init_anglemeas_object_m(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
+    va_list args;
+    F_point *pp;
+    F_point *pq;
+
+    va_start(args, y);
+    pp = va_arg(args, F_point*);
+    pq = va_arg(args, F_point*);
+    va_end(args);
+
     save_rotnangle = 1;
-    init_anglemeas_object(p, type, x, y, pp, pq);
+    init_anglemeas_object(obj, type, pq);
 }
 
 static void
-init_anglemeas_object_r(char *p, int type, int x, int y, F_point *pp, F_point *pq)
+init_anglemeas_object_r(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
+    va_list args;
+    F_point *pp;
+    F_point *pq;
+
+    va_start(args, y);
+    pp = va_arg(args, F_point*);
+    pq = va_arg(args, F_point*);
+    va_end(args);
+
     save_rotnangle = 0;
-    init_anglemeas_object(p, type, x, y, pp, pq);
+    init_anglemeas_object(obj, type, pq);
 }
 
 static void
-init_anglemeas_object(char *p, int type, int x, int y, F_point *pp, F_point *pq)
+init_anglemeas_object(void *obj, int type, F_point *pq)
 {
-	(void)x;
-	(void)y;
-	(void)pp;
-
     switch(type) {
     case O_POLYLINE:
-        cur_l = (F_line*)p;
+        cur_l = (F_line*)obj;
         anglemeas_line(cur_l, pq); /* do_point_search returns `near' point in *q */
         break;
     case O_ARC:
-        cur_a = (F_arc*)p;
+        cur_a = (F_arc*)obj;
         anglemeas_arc(cur_a); /* point doesn't matter */
         break;
     default:
@@ -328,9 +348,8 @@ void lenmeas_selected(void)
 }
 
 static void
-init_lenmeas_object(char *p, int type, int x, int y, int px, int py)
+init_lenmeas_object(void *obj, int type)
 {
-	(void)x; (void)y; (void)px; (void)py;
     float	    len;
     double	    a,b,z;
     int		    ok;
@@ -340,7 +359,7 @@ init_lenmeas_object(char *p, int type, i
 
     switch (type) {
       case O_POLYLINE:
-	cur_l = (F_line*) p;
+	cur_l = (F_line*) obj;
 	(void) compute_poly_length(cur_l, &len);
 	if (cur_l->type == T_BOX || cur_l->type == T_PICTURE)
 	    msgtext = "box";
@@ -356,7 +375,7 @@ init_lenmeas_object(char *p, int type, i
 	break;
 
       case O_ARC:
-	cur_a = (F_arc*) p;
+	cur_a = (F_arc*) obj;
 	if (compute_arc_length(cur_a, &len)) {
 	    msgtext = "arc";
 	    ok = 1;
@@ -364,7 +383,7 @@ init_lenmeas_object(char *p, int type, i
 	break;
 
       case O_ELLIPSE:
-	cur_e = (F_ellipse*) p;
+	cur_e = (F_ellipse*) obj;
 	/* ellipse or circle? */
 	if (cur_e->radiuses.x == cur_e->radiuses.y) {
 	    msgtext = "circle";
@@ -395,17 +414,23 @@ init_lenmeas_object(char *p, int type, i
 }
 
 static void
-init_lenmeas_object_l(char *p, int type, int x, int y, int px, int py)
+init_lenmeas_object_l(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
   save_len = 0;
-  init_lenmeas_object(p, type, x, y, px, py);
+  init_lenmeas_object(obj, type);
 }
 
 static void
-init_lenmeas_object_m(char *p, int type, int x, int y, int px, int py)
+init_lenmeas_object_m(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
   save_len = 1;
-  init_lenmeas_object(p, type, x, y, px, py);
+  init_lenmeas_object(obj, type);
 }
 
 static void
@@ -441,9 +466,8 @@ void areameas_selected(void)
 
 
 static void
-init_areameas_object(char *p, int type, int x, int y, int px, int py)
+init_areameas_object(void *obj, int type)
 {
-	(void)x; (void)y; (void)px; (void)py;
     float	    area;
     int		    ok;
     char	   *msgtext;
@@ -452,7 +476,7 @@ init_areameas_object(char *p, int type,
 
     switch (type) {
       case O_POLYLINE:
-	cur_l = (F_line*) p;
+	cur_l = (F_line*) obj;
 	if (1) {
 	    compute_poly_area(cur_l, &area);
 	    if (cur_l->type == T_BOX)
@@ -469,7 +493,7 @@ init_areameas_object(char *p, int type,
 	break;
 
       case O_ARC:
-	cur_a = (F_arc*) p;
+	cur_a = (F_arc*) obj;
 	if (compute_arc_area(cur_a, &area)) {
 	    if (cur_a->type == T_OPEN_ARC)
 		msgtext = "open arc";
@@ -480,7 +504,7 @@ init_areameas_object(char *p, int type,
 	break;
 
       case O_ELLIPSE:
-	cur_e = (F_ellipse*) p;
+	cur_e = (F_ellipse*) obj;
 	if (compute_ellipse_area(cur_e, &area)) {
 	    msgtext = "ellipse";
 	    ok = 1;
@@ -503,17 +527,23 @@ init_areameas_object(char *p, int type,
 }
 
 static void
-init_areameas_object_l(char *p, int type, int x, int y, int px, int py)
+init_areameas_object_l(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
   save_area = 0;
-  init_areameas_object(p, type, x, y, px, py);
+  init_areameas_object(obj, type);
 }
 
 static void
-init_areameas_object_m(char *p, int type, int x, int y, int px, int py)
+init_areameas_object_m(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
   save_area = 1;
-  init_areameas_object(p, type, x, y, px, py);
+  init_areameas_object(obj, type);
 }
 
 static void
--- a/src/e_move.c
+++ b/src/e_move.c
@@ -16,6 +16,8 @@
  *
  */
 
+#include <stdarg.h>
+
 #include "e_move.h"
 
 #include "resources.h"
@@ -32,10 +34,9 @@
 #include "w_mousefun.h"
 
 
-static void	init_move(F_line *p, int type, int x, int y, int px, int py);
-static void	init_arb_move(F_line *p, int type, int x, int y, int px,int py);
-static void	init_constrained_move(F_line *p, int type, int x, int y, int px,
-					int py);
+static void	init_move(void *obj, int type, int x, int y, int px, int py);
+static void	init_arb_move(void *obj, int type, int x, int y, ...);
+static void	init_constrained_move(void *obj, int type, int x, int y, ...);
 
 
 void
@@ -55,20 +56,38 @@ move_selected(void)
 }
 
 static void
-init_arb_move(F_line *p, int type, int x, int y, int px, int py)
+init_arb_move(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     constrained = MOVE_ARB;
-    init_move(p, type, x, y, px, py);
+    init_move(obj, type, x, y, px, py);
     canvas_middlebut_proc = null_proc_button;
     set_mousefun("place object", "", "cancel", LOC_OBJ, LOC_OBJ, LOC_OBJ);
     draw_mousefun_canvas();
 }
 
 static void
-init_constrained_move(F_line *p, int type, int x, int y, int px, int py)
+init_constrained_move(void *obj, int type, int x, int y, ...)
 {
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     constrained = MOVE_HORIZ_VERT;
-    init_move(p, type, x, y, px, py);
+    init_move(obj, type, x, y, px, py);
     canvas_middlebut_proc = canvas_leftbut_proc;
     canvas_leftbut_proc = null_proc_button;
     set_mousefun("", "place object", "cancel", LOC_OBJ, LOC_OBJ, LOC_OBJ);
@@ -76,14 +95,14 @@ init_constrained_move(F_line *p, int typ
 }
 
 static void
-init_move(F_line *p, int type, int x, int y, int px, int py)
+init_move(void *obj, int type, int x, int y, int px, int py)
 {
     /* turn off all markers */
     update_markers(0);
     switch (type) {
     case O_COMPOUND:
 	set_cursor(wait_cursor);
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *) obj;
 	list_delete_compound(&objects.compounds, cur_c);
 	redisplay_compound(cur_c);
 	set_cursor(null_cursor);
@@ -91,7 +110,7 @@ init_move(F_line *p, int type, int x, in
 	break;
     case O_POLYLINE:
 	set_cursor(wait_cursor);
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	list_delete_line(&objects.lines, cur_l);
 	redisplay_line(cur_l);
 	set_cursor(null_cursor);
@@ -99,7 +118,7 @@ init_move(F_line *p, int type, int x, in
 	break;
     case O_TXT:
 	set_cursor(wait_cursor);
-	cur_t = (F_text *) p;
+	cur_t = (F_text *) obj;
 	list_delete_text(&objects.texts, cur_t);
 	redisplay_text(cur_t);
 	set_cursor(null_cursor);
@@ -107,7 +126,7 @@ init_move(F_line *p, int type, int x, in
 	break;
     case O_ELLIPSE:
 	set_cursor(wait_cursor);
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *) obj;
 	list_delete_ellipse(&objects.ellipses, cur_e);
 	redisplay_ellipse(cur_e);
 	set_cursor(null_cursor);
@@ -115,7 +134,7 @@ init_move(F_line *p, int type, int x, in
 	break;
     case O_ARC:
 	set_cursor(wait_cursor);
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *) obj;
 	list_delete_arc(&objects.arcs, cur_a);
 	redisplay_arc(cur_a);
 	set_cursor(null_cursor);
@@ -123,7 +142,7 @@ init_move(F_line *p, int type, int x, in
 	break;
     case O_SPLINE:
 	set_cursor(wait_cursor);
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	list_delete_spline(&objects.splines, cur_s);
 	redisplay_spline(cur_s);
 	set_cursor(null_cursor);
--- a/src/e_movept.c
+++ b/src/e_movept.c
@@ -60,9 +60,9 @@ static void	relocate_ellipsepoint(F_elli
 static void	relocate_linepoint(F_line *line, int x, int y, F_point *moved_point, F_point *left_point);
 static void	relocate_splinepoint(F_spline *s, int x, int y, F_point *moved_point);
 
-static Boolean	init_move_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q, int pnum);
-static void	init_arb_move_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q, int pnum);
-static void	init_stretch_move_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q, int pnum);
+static Boolean	init_move_point(F_line *obj, int type, F_point *p, F_point *q, int pnum);
+static void	init_arb_move_point(void *obj, int type, int x, int y, ...);
+static void	init_stretch_move_point(void *obj, int type, int x, int y, ...);
 
 static void	fix_movedarcpoint(int x, int y, unsigned int shift);
 static void	fix_movedellipsepoint(int x, int y, unsigned int shift);
@@ -94,10 +94,24 @@ void move_point_selected(void)
 }
 
 static void
-init_arb_move_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q, int pnum)
+init_arb_move_point(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
+    va_list args;
+    F_point *p;
+    F_point *q;
+    int pnum;
+
+    va_start(args, y);
+    p = va_arg(args, F_point*);
+    q = va_arg(args, F_point*);
+    pnum = va_arg(args, int);
+    va_end(args);
+
     constrained = MOVE_ARB;
-    if (!init_move_point(obj, type, x, y, p, q, pnum))
+    if (!init_move_point(obj, type, p, q, pnum))
 	return;
     set_mousefun("new posn", "", "cancel", LOC_OBJ, LOC_OBJ, LOC_OBJ);
     draw_mousefun_canvas();
@@ -105,10 +119,24 @@ init_arb_move_point(F_line *obj, int typ
 }
 
 static void
-init_stretch_move_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q, int pnum)
+init_stretch_move_point(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
+    va_list args;
+    F_point *p;
+    F_point *q;
+    int pnum;
+
+    va_start(args, y);
+    p = va_arg(args, F_point*);
+    q = va_arg(args, F_point*);
+    pnum = va_arg(args, int);
+    va_end(args);
+
     constrained = MOVE_HORIZ_VERT;
-    if (!init_move_point(obj, type, x, y, p, q, pnum))
+    if (!init_move_point(obj, type, p, q, pnum))
 	return;
     set_mousefun("", "new posn", "cancel", LOC_OBJ, LOC_OBJ, LOC_OBJ);
     draw_mousefun_canvas();
@@ -117,12 +145,8 @@ init_stretch_move_point(F_line *obj, int
 }
 
 static Boolean
-init_move_point(F_line *obj, int type, int x, int y, F_point *p, F_point *q,
-		int pnum)
+init_move_point(F_line *obj, int type, F_point *p, F_point *q, int pnum)
 {
-	(void)x;
-	(void)y;
-
     left_point = p;
     moved_point = q;
     switch (type) {
--- a/src/e_rotate.c
+++ b/src/e_rotate.c
@@ -18,6 +18,7 @@
 
 #include "e_rotate.h"
 
+#include <stdarg.h>
 #include <stddef.h>
 #include <math.h>
 
@@ -54,11 +55,11 @@ float		act_rotnangle;
 
 static int	copy;
 
-static void	init_rotate(F_line *p, int type, int x, int y, int px, int py);
+static void	init_rotate(void *obj, int type, int x, int y, ...);
 static void	set_unset_center(int x, int y, unsigned int shift);
-static void	init_copynrotate(F_line *p, int type, int x,int y,int px,int py);
+static void	init_copynrotate(void *obj, int type, int x, int y, ...);
 static void	rotate_selected(void);
-static void	rotate_search(F_line *p, int type, int x, int y, int px, int py);
+static void	rotate_search(F_line *p, int type, int px, int py);
 static void	init_rotateline(F_line *l, int px, int py);
 static void	init_rotatetext(F_text *t, int px, int py);
 static void	init_rotatearc (F_arc *a, int px, int py);
@@ -147,39 +148,59 @@ set_unset_center(int x, int y, unsigned
 }
 
 static void
-init_rotate(F_line *p, int type, int x, int y, int px, int py)
+init_rotate(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     copy = 0;
     act_rotnangle = cur_rotnangle;
     if (setcenter)
-        rotate_search(p, type, x, y,setcenter_x,setcenter_y );
+        rotate_search(obj, type, setcenter_x,setcenter_y );
       /* remember rotation center, e.g for multiple rotation*/
     else
-        rotate_search(p, type, x, y, px, py);
+        rotate_search(obj, type, px, py);
 }
 
 static void
-init_copynrotate(F_line *p, int type, int x, int y, int px, int py)
+init_copynrotate(void *obj, int type, int x, int y, ...)
 {
+	(void)x;
+	(void)y;
+
+    va_list args;
+    int px;
+    int py;
     int		    i;
 
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     copy = 1;
     act_rotnangle = cur_rotnangle;
     for ( i = 1; i <= cur_numcopies; act_rotnangle += cur_rotnangle, i++) {
 	if (setcenter)
-	    rotate_search(p, type, x, y,setcenter_x,setcenter_y );
+	    rotate_search(obj, type, setcenter_x,setcenter_y );
 	/* remember rotation center */
 	else
-            rotate_search(p, type, x, y, px, py);
+            rotate_search(obj, type, px, py);
     }
 }
 
 static void
-rotate_search(F_line *p, int type, int x, int y, int px, int py)
+rotate_search(F_line *p, int type, int px, int py)
 {
-	(void)x;
-	(void)y;
-
     switch (type) {
     case O_POLYLINE:
 	cur_l = (F_line *) p;
--- a/src/e_scale.c
+++ b/src/e_scale.c
@@ -22,6 +22,7 @@
 #include "e_scale.h"
 
 #include <math.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -71,10 +72,9 @@ static void	scale_text(F_text *t, float
 static void	scale_arrows(F_line *obj, float sx, float sy);
 static void	scale_arrow(F_arrow *arrow, float sx, float sy);
 
-static void	init_box_scale(F_line *obj, int type, int x,int y,int px,int py);
+static void	init_box_scale(void *obj, int type, int x, int y, ...);
 static void	boxrelocate_ellipsepoint(F_ellipse *ellipse, int x, int y);
-static void	init_center_scale(F_line *obj, int type, int x, int y,
-				int px, int py);
+static void	init_center_scale(void *obj, int type, int x, int y, ...);
 static void	init_scale_compound(void);
 static void	rescale_points(F_line *obj, int x, int y);
 static void	relocate_ellipsepoint(F_ellipse *ellipse, int x, int y);
@@ -121,11 +121,20 @@ char *BOX_SCL_MSG = "Can't use box scale
 char *BOX_SCL2_MSG = "Can't use box scale on selected object; try putting it into a compound";
 
 static void
-init_box_scale(F_line *obj, int type, int x, int y, int px, int py)
+init_box_scale(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
 
+    va_list args;
+    int px;
+    int py;
+
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     switch (type) {
     case O_POLYLINE:
 	cur_l = (F_line *) obj;
@@ -153,12 +162,21 @@ init_box_scale(F_line *obj, int type, in
 }
 
 static void
-init_center_scale(F_line *obj, int type, int x, int y, int px, int py)
+init_center_scale(void *obj, int type, int x, int y, ...)
 {
 	(void)x;
 	(void)y;
+
+    va_list args;
+    int px;
+    int py;
     double	    dx, dy, l;
 
+    va_start(args, y);
+    px = va_arg(args, int);
+    py = va_arg(args, int);
+    va_end(args);
+
     cur_x = from_x = px;
     cur_y = from_y = py;
     constrained = BOX_SCALE;
--- a/src/e_tangent.c
+++ b/src/e_tangent.c
@@ -16,6 +16,7 @@
 #include "e_tangent.h"
 
 #include <math.h>
+#include <stdarg.h>
 #include <stddef.h>
 
 #include "resources.h"
@@ -37,10 +38,8 @@
 
 #define ZERO_TOLERANCE 2.0
 
-static void	init_tangent_adding(char *p, int type, int x, int y,
-					int px, int py);
-static void	init_normal_adding(char *p, int type, int x, int y,
-					int px, int py);
+static void	init_tangent_adding(void *obj, int type, int x, int y, ...);
+static void	init_normal_adding(void *obj, int type, int x, int y, ...);
 static void	tangent_or_normal(int x, int y, int flag);
 static void	tangent_normal_line(int x, int y, float vx, float vy);
 
@@ -65,17 +64,35 @@ tangent_selected(void)
 /*  smart_point1, smart_point2 are two points of the tangent */
 
 static void
-init_tangent_adding(char *p, int type, int x, int y, int px, int py)
+init_tangent_adding(void *obj, int type, int x, int y, ...)
 {
-	(void)p; (void)type; (void)x; (void)y;
+	(void)obj; (void)type; (void)x; (void)y;
+
+	va_list args;
+	int px;
+	int py;
+
+	va_start(args, y);
+	px = va_arg(args, int);
+	py = va_arg(args, int);
+	va_end(args);
 
 	tangent_or_normal(px, py, 0);
 }
 
 static void
-init_normal_adding(char *p, int type, int x, int y, int px, int py)
+init_normal_adding(void *obj, int type, int x, int y, ...)
 {
-	(void)p; (void)type; (void)x; (void)y;
+	(void)obj; (void)type; (void)x; (void)y;
+
+	va_list args;
+	int px;
+	int py;
+
+	va_start(args, y);
+	px = va_arg(args, int);
+	py = va_arg(args, int);
+	va_end(args);
 
 	tangent_or_normal(px, py, 1);
 }
--- a/src/e_update.c
+++ b/src/e_update.c
@@ -55,10 +55,8 @@
 static Boolean	keep_depth = False;
 static int	delta_depth;
 
-static void	init_update_object(F_line *p, int type, int x, int y,
-					int px, int py);
-static void	init_update_settings(F_line *p, int type, int x, int y,
-					int px, int py);
+static void	init_update_object(void *obj, int type, int x, int y, ...);
+static void	init_update_settings(void *obj, int type, int x, int y, ...);
 
 
 #define min(a,b) ((a)<(b)) ? (a) : (b)
@@ -140,16 +138,16 @@ get_arrow_type(F_line *object)
 /* update the indicator buttons FROM the selected object */
 
 static void
-init_update_settings(F_line *p, int type, int x, int y, int px, int py)
+init_update_settings(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
     int		    old_psfont_flag, new_psfont_flag;
     F_line	   *dline, *dtick1, *dtick2, *dbox;
     F_text	   *dtext;
 
     switch (type) {
       case O_COMPOUND:
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *) obj;
 
 	/* if this is a dimension line, update the dimline settings from it */
 	if (dimline_components(cur_c, &dline, &dtick1, &dtick2, &dbox)) {
@@ -199,7 +197,7 @@ init_update_settings(F_line *p, int type
 	}
 	break;
       case O_POLYLINE:
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	if (cur_l->type != T_PICTURE) {
 		up_part(cur_linewidth, cur_l->thickness, I_LINEWIDTH);
 		up_part(cur_fillstyle, cur_l->fill_style, I_FILLSTYLE);
@@ -226,7 +224,7 @@ init_update_settings(F_line *p, int type
 	    up_part(cur_boxradius, cur_l->radius, I_BOXRADIUS);
 	break;
       case O_TXT:
-	cur_t = (F_text *) p;
+	cur_t = (F_text *) obj;
 	up_part(cur_textjust, cur_t->type, I_TEXTJUST);
 	up_part(cur_pencolor, cur_t->color, I_PEN_COLOR);
 	up_depth_part(cur_depth, cur_t->depth);
@@ -248,7 +246,7 @@ init_update_settings(F_line *p, int type
 	up_part(cur_fontsize, cur_t->size, I_FONTSIZE);
 	break;
       case O_ELLIPSE:
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *) obj;
 	up_part(cur_linewidth, cur_e->thickness, I_LINEWIDTH);
 	up_part(cur_elltextangle, cur_e->angle/M_PI*180.0, I_ELLTEXTANGLE);
 	up_part(cur_fillstyle, cur_e->fill_style, I_FILLSTYLE);
@@ -261,7 +259,7 @@ init_update_settings(F_line *p, int type
 	up_depth_part(cur_depth, cur_e->depth);
 	break;
       case O_ARC:
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *) obj;
 	up_part(cur_linewidth, cur_a->thickness, I_LINEWIDTH);
 	up_part(cur_fillstyle, cur_a->fill_style, I_FILLSTYLE);
 	up_part(cur_pencolor, cur_a->pen_color, I_PEN_COLOR);
@@ -281,7 +279,7 @@ init_update_settings(F_line *p, int type
 		up_from_arrow(cur_a->for_arrow,cur_a->thickness);
 	break;
       case O_SPLINE:
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	up_part(cur_linewidth, cur_s->thickness, I_LINEWIDTH);
 	up_part(cur_fillstyle, cur_s->fill_style, I_FILLSTYLE);
 	up_part(cur_pencolor, cur_s->pen_color, I_PEN_COLOR);
@@ -331,9 +329,9 @@ void up_from_arrow(F_arrow *arrow, int t
 /* update the selected object FROM the indicator buttons */
 
 static void
-init_update_object(F_line *p, int type, int x, int y, int px, int py)
+init_update_object(void *obj, int type, int x, int y, ...)
 {
-	(void)x; (void)y; (void)px; (void)py;
+	(void)x; (void)y;
     int		    largest;
     Boolean	    dontupdate;
 
@@ -342,7 +340,7 @@ init_update_object(F_line *p, int type,
     switch (type) {
       case O_COMPOUND:
 	set_temp_cursor(wait_cursor);
-	cur_c = (F_compound *) p;
+	cur_c = (F_compound *) obj;
 	new_c = copy_compound(cur_c);
 
 	/* keep the depths of the objects inside the compound the same
@@ -371,7 +369,7 @@ init_update_object(F_line *p, int type,
 	break;
       case O_POLYLINE:
 	set_temp_cursor(wait_cursor);
-	cur_l = (F_line *) p;
+	cur_l = (F_line *) obj;
 	new_l = copy_line(cur_l);
 	update_line(new_l);
 	change_line(cur_l, new_l);
@@ -382,7 +380,7 @@ init_update_object(F_line *p, int type,
 	break;
       case O_TXT:
 	set_temp_cursor(wait_cursor);
-	cur_t = (F_text *) p;
+	cur_t = (F_text *) obj;
 	new_t = copy_text(cur_t);
 	update_text(new_t);
 	change_text(cur_t, new_t);
@@ -391,7 +389,7 @@ init_update_object(F_line *p, int type,
 	break;
       case O_ELLIPSE:
 	set_temp_cursor(wait_cursor);
-	cur_e = (F_ellipse *) p;
+	cur_e = (F_ellipse *) obj;
 	new_e = copy_ellipse(cur_e);
 	update_ellipse(new_e);
 	change_ellipse(cur_e, new_e);
@@ -402,7 +400,7 @@ init_update_object(F_line *p, int type,
 	break;
       case O_ARC:
 	set_temp_cursor(wait_cursor);
-	cur_a = (F_arc *) p;
+	cur_a = (F_arc *) obj;
 	new_a = copy_arc(cur_a);
 	update_arc(new_a);
 	change_arc(cur_a, new_a);
@@ -413,7 +411,7 @@ init_update_object(F_line *p, int type,
 	break;
       case O_SPLINE:
 	set_temp_cursor(wait_cursor);
-	cur_s = (F_spline *) p;
+	cur_s = (F_spline *) obj;
 	new_s = copy_spline(cur_s);
 	update_spline(new_s);
 	change_spline(cur_s, new_s);
--- a/src/u_search.c
+++ b/src/u_search.c
@@ -43,10 +43,10 @@
 #define TOLERANCE ((int)((display_zoomscale < 20.0? 10: 14) * \
 			PIX_PER_INCH/DISPLAY_PIX_PER_INCH/display_zoomscale))
 
-static void	(*manipulate) ();
-static void	(*handlerproc_left) ();
-static void	(*handlerproc_middle) ();
-static void	(*handlerproc_right) ();
+static void	(*manipulate) (void *obj, int type, int x, int y, ...);
+static void	(*handlerproc_left) (void *obj, int type, int x, int y, ...);
+static void	(*handlerproc_middle) (void *obj, int type, int x, int y, ...);
+static void	(*handlerproc_right) (void *obj, int type, int x, int y, ...);
 static int	type;
 static long	objectcount;
 static long	n;
@@ -743,19 +743,19 @@ next_compound_point_found(int x, int y,
 }
 
 void
-init_searchproc_left(void (*handlerproc) (/* ??? */))
+init_searchproc_left(void (*handlerproc) (void *obj, int type, int x, int y, ...))
 {
     handlerproc_left = handlerproc;
 }
 
 void
-init_searchproc_middle(void (*handlerproc) (/* ??? */))
+init_searchproc_middle(void (*handlerproc) (void *obj, int type, int x, int y, ...))
 {
     handlerproc_middle = handlerproc;
 }
 
 void
-init_searchproc_right(void (*handlerproc) (/* ??? */))
+init_searchproc_right(void (*handlerproc) (void *obj, int type, int x, int y, ...))
 {
     handlerproc_right = handlerproc;
 }
--- a/src/u_search.h
+++ b/src/u_search.h
@@ -24,9 +24,9 @@
 
 Boolean		in_text_bound(F_text *t, int x, int y);
 
-void		init_searchproc_left(void (*handlerproc) (/* ??? */));
-void		init_searchproc_middle(void (*handlerproc) (/* ??? */));
-void		init_searchproc_right(void (*handlerproc) (/* ??? */));
+void		init_searchproc_left(void (*handlerproc) (void *obj, int type, int x, int y, ...));
+void		init_searchproc_middle(void (*handlerproc) (void *obj, int type, int x, int y, ...));
+void		init_searchproc_right(void (*handlerproc) (void *obj, int type, int x, int y, ...));
 
 void		point_search_left(int x, int y, unsigned int shift);
 void		point_search_middle(int x, int y, unsigned int shift);
--- a/src/u_smartsearch.c
+++ b/src/u_smartsearch.c
@@ -59,10 +59,10 @@ void smart_toggle_objecthighlight(void);
 F_point  smart_point1, smart_point2;
 
 /* locals: */
-static void	(*manipulate) ();
-static void	(*handlerproc_left) ();
-static void	(*handlerproc_middle) ();
-static void	(*handlerproc_right) ();
+static void	(*manipulate) (void *, int type, int x, int y, ...);
+static void	(*handlerproc_left) (void *, int type, int x, int y, ...);
+static void	(*handlerproc_middle) (void *, int type, int x, int y, ...);
+static void	(*handlerproc_right) (void *, int type, int x, int y, ...);
 static int	type;
 static long	objectcount;
 static long	n;
@@ -82,19 +82,19 @@ static F_compound *c;
 
 
 void
-init_smart_searchproc_left(void (*handlerproc) (/* ??? */))
+init_smart_searchproc_left(void (*handlerproc) (void *, int type, int x, int y, ...))
 {
     handlerproc_left = handlerproc;
 }
 
 void
-init_smart_searchproc_middle(void (*handlerproc) (/* ??? */))
+init_smart_searchproc_middle(void (*handlerproc) (void *, int type, int x, int y, ...))
 {
     handlerproc_middle = handlerproc;
 }
 
 void
-init_smart_searchproc_right(void (*handlerproc) (/* ??? */))
+init_smart_searchproc_right(void (*handlerproc) (void *, int type, int x, int y, ...))
 {
     handlerproc_right = handlerproc;
 }
--- a/src/u_smartsearch.h
+++ b/src/u_smartsearch.h
@@ -23,9 +23,9 @@
 
 #include "object.h"
 
-void		init_smart_searchproc_left(void (*handlerproc) (/* ??? */));
-void		init_smart_searchproc_middle(void (*handlerproc) (/* ??? */));
-void		init_smart_searchproc_right(void (*handlerproc) (/* ??? */));
+void		init_smart_searchproc_left(void (*handlerproc) (void *obj, int type, int x, int y, ...));
+void		init_smart_searchproc_middle(void (*handlerproc) (void *obj, int type, int x, int y, ...));
+void		init_smart_searchproc_right(void (*handlerproc) (void *obj, int type, int x, int y, ...));
 
 void		smart_object_search_left(int x, int y, unsigned int shift);
 void		smart_object_search_middle(int x, int y, unsigned int shift);
--- a/src/w_snap.c
+++ b/src/w_snap.c
@@ -1036,16 +1036,15 @@ snap_ellipse_handler(F_ellipse *e, int x
 }
 
 static void
-snap_handler(void *p, int type, int x, int y, int px, int py)
+snap_handler(void *obj, int type, int x, int y, ...)
 {
-	(void)px; (void)py;
   static void * intersect_object_1;
   static int intersect_type_1;
 
   if (snap_mode == SNAP_MODE_INTERSECT) {
     switch(intersect_state) {
     case INTERSECT_INITIAL:
-      intersect_object_1 = p;
+      intersect_object_1 = obj;
       intersect_type_1 = type;
       intersect_state = INTERSECT_FIRST_FOUND;
       XtVaSetValues(snap_indicator_label, XtNlabel, "I'sect 2 " , NULL);
@@ -1053,7 +1052,7 @@ snap_handler(void *p, int type, int x, i
       snap_msg_set = True;
       break;
     case INTERSECT_FIRST_FOUND:
-      snap_intersect_handler(intersect_object_1, intersect_type_1, p, type, x, y);
+      snap_intersect_handler(intersect_object_1, intersect_type_1, obj, type, x, y);
       intersect_state = INTERSECT_INITIAL;
       XtVaSetValues(snap_indicator_label, XtNlabel, "Intersect" , NULL);
       break;
@@ -1062,19 +1061,19 @@ snap_handler(void *p, int type, int x, i
   else {
     switch (type) {
     case O_ELLIPSE:
-      snap_ellipse_handler(p, x, y);
+      snap_ellipse_handler(obj, x, y);
       break;
     case O_POLYLINE:
-      snap_polyline_handler(p, x, y);
+      snap_polyline_handler(obj, x, y);
       break;
     case O_SPLINE:
-      snap_spline_handler(p, x, y);
+      snap_spline_handler(obj, x, y);
       break;
     case O_TXT:
-      snap_text_handler(p, x, y);
+      snap_text_handler(obj, x, y);
       break;
     case O_ARC:
-      snap_arc_handler(p, x, y);
+      snap_arc_handler(obj, x, y);
       break;
     }
   }