Changeset 5414

Timestamp:

08/10/09 15:51:51 (4 years ago)

Author:

werner

Message:

• File>Save now saves to a file if a second name is given on the command line, to stdout if not
• there's no reason anymore to disallow editing the offset in new-style measurements
• struct inst_ops is no longer opaque, so we can avoid adding even more silly little access functions and open-code straightforward callbacks
• (re)stuctured hover/click/drag logic in gui_tool.c
• added optional debugging output to gui_canvas.c
• don't let a vector's base be dragged onto the vector's own end or onto one of its children
• measurements can now be properly changed by dragging

Location:

trunk/eda/fped

Files:

• TODO (modified) (2 diffs)
• fped.c (modified) (4 diffs)
• gui.c (modified) (3 diffs)
• gui_canvas.c (modified) (7 diffs)
• gui_meas.c (modified) (10 diffs)
• gui_meas.h (modified) (1 diff)
• gui_tool.c (modified) (12 diffs)
• gui_tool.h (modified) (2 diffs)
• inst.c (modified) (8 diffs)
• inst.h (modified) (3 diffs)
• meas.c (modified) (1 diff)
• meas.h (modified) (1 diff)

trunk/eda/fped/TODO

@@ -3 +3 @@
 - add default unit (combine with grid unit selection ?)
 - consider adding auto/mm/mil selection for each dimension
-- add measurements (partly done. still needed: find out how to define
-  non-trivial endpoints, e.g., some vector in last iteration of loop)
 - add KiCad output
 - add postscript output
@@ -36 +34 @@
 - merge find_var_in_frame with similar mechanisms in expr.c and fpd.y
 - add regression tests
+- the drag logic is too complex. Better: let tool/instance just generate the
+  list of points at each stage, then handle the highlighting and hovering
+  inside a dragging module.
 
 Open decisions:

trunk/eda/fped/fped.c

@@ -12 +12 @@
 
 
+#include <stdlib.h>
+#include <stdio.h>
 
 #include "cpp.h"
@@ -24 +26 @@
 extern int yyparse(void);
 
+char *save_file = NULL;
+
 
 static void load_file(const char *name)
@@ -33 +37 @@
 
 
+static void usage(const char *name)
+{
+        fprintf(stderr, "usage: %s [in_file [out_file]]\n", name);
+        exit(1);
+}
+
+
 int main(int argc, char **argv)
 {
+        const char *name = *argv;
         int error;
 
@@ -40 +52 @@
         if (error)
                 return error;
-        if (argc == 1) {
+        switch (argc) {
+        case 1:
                 scan_empty();
                 (void) yyparse();
-        } else {
+                break;
+        case 3:
+                save_file = argv[2];
+                /* fall through */
+        case 2:
                 load_file(argv[1]);
-                argc--;
-                argv++;
+                break;
+        default:
+                usage(name);
         }
 

trunk/eda/fped/gui.c

@@ -12 +12 @@
 
 
+#include <stdio.h>
 #include <gtk/gtk.h>
 
@@ -31 +32 @@
 
 
+extern char *save_file;
+
 GtkWidget *root;
 int show_stuff = 1;
@@ -46 +49 @@
 static void menu_save(GtkWidget *widget, gpointer user)
 {
-        dump(stdout);
+        FILE *file;
+
+        if (!save_file) {
+                if (!dump(stdout))
+                        perror("stdout");
+                return;
+        }
+        file = fopen(save_file, "w");
+        if (!file) {
+                perror(save_file);
+                return;
+        }
+        if (!dump(file))
+                perror(save_file);
+        if (fclose(file) == EOF)
+                perror(save_file);
 }
 

trunk/eda/fped/gui_canvas.c

@@ -26 +26 @@
 #include "gui.h"
 #include "gui_canvas.h"
+
+
+#if 0
+#define DPRINTF(fmt, ...)       fprintf(stderr, fmt "\n", ##__VA_ARGS__)
+#else
+#define DPRINTF(fmt, ...)
+#endif
 
 
@@ -140 +147 @@
         struct coord pos = canvas_to_coord(event->x, event->y);
 
+        DPRINTF("--- motion ---");
         curr_pos.x = event->x;
         curr_pos.y = event->y;
@@ -162 +170 @@
         int res;
 
+        DPRINTF("--- button press ---");
         gtk_widget_grab_focus(widget);
         switch (event->button) {
@@ -207 +216 @@
         struct coord pos = canvas_to_coord(event->x, event->y);
 
+        DPRINTF("--- button release ---");
         switch (event->button) {
         case 1:
@@ -292 +302 @@
         struct coord pos = canvas_to_coord(curr_pos.x, curr_pos.y);
 
+        DPRINTF("--- key press ---");
         switch (event->keyval) {
         case ' ':
@@ -351 +362 @@
 {
         static int first = 1;
+
+        DPRINTF("--- expose ---");
         if (first) {
                 init_canvas();
                 first = 0;
         }
+        tool_dehover();
         redraw();
         return TRUE;
@@ -374 +388 @@
     gpointer data)
 {
+        DPRINTF("--- leave ---");
         if (dragging)
                 tool_cancel_drag();

trunk/eda/fped/gui_meas.c

@@ -13 +13 @@
 
 #include "util.h"
+#include "coord.h"
 #include "meas.h"
+#include "inst.h"
 #include "gui_canvas.h"
 #include "gui_tool.h"
@@ -154 +156 @@
                 return is_min(meas_dsc->lt, inst);
         case next_to_min:
-                return is_min_of_next(meas_dsc->lt, inst, a);
+                if (!is_min(meas_dsc->lt, inst))
+                        return 0;
+                return is_next(meas_dsc->lt, a, inst);
+//              return is_min_of_next(meas_dsc->lt, inst, a);
         default:
                 abort();
@@ -223 +228 @@
 
 
-/* ----- find point ------------------------------------------------------- */
-
-
-static struct inst *find_point_meas(struct coord pos)
+/* ----- find start point (new measurement) -------------------------------- */
+
+
+static struct inst *find_point_meas_new(struct coord pos)
 {
         if (meas_inst)
@@ -261 +266 @@
 
         meas_inst = NULL;
+        highlight = NULL;
         if (from == to)
                 return 0;
@@ -291 +297 @@
         }
         meas->inverted =
-          mode == min_to_next_or_max && is_min(meas_dsc->lt, to) ? 0 :
-          meas_dsc->lt(from->u.rect.end, to->u.rect.end) !=
-          (mode == min_to_next_or_max);
+            mode == min_to_next_or_max && is_min(meas_dsc->lt, to) ? 0 :
+            meas_dsc->lt(from->u.rect.end, to->u.rect.end) !=
+            (mode == min_to_next_or_max);
 {
 char *sm[] = { "min_to", "max_to", "next_to" };
@@ -306 +312 @@
 
 
+static void cancel_drag_new_meas(void)
+{
+        meas_inst = NULL;
+        highlight = NULL;
+        redraw();
+}
+
+
 /* ----- begin dragging existing measurement ------------------------------- */
+
+
+/*
+ * We didn't record which instance provided the vector we're using here, so we
+ * have to search for it now.
+ */
+
+static struct inst *vec_at(const struct vec *vec, struct coord pos)
+{
+        struct inst *inst;
+        const struct sample *s;
+
+        for (inst = insts_ip_vec(); inst; inst = inst->next)
+                if (inst->vec == vec)
+                        for (s = vec->samples; s; s = s->next)
+                                if (coord_eq(s->pos, pos))
+                                        return inst;
+        abort();
+}
 
 
@@ -329 +362 @@
                 abort();
         }
+        highlight = meas_highlight_b;
         switch (i) {
         case 0:
-                highlight = meas_highlight_a;
                 mode = meas->type < 3 ? next_to_min : max_to_min;
+                meas_inst = vec_at(inst->obj->u.meas.high, inst->u.meas.end);
                 break;
         case 1:
-                highlight = meas_highlight_b;
                 mode = min_to_next_or_max;
+                meas_inst = vec_at(inst->obj->base, inst->base);
                 break;
         default:
                 abort();
         }
+//      redraw();
+}
+
+
+/* ----- find end point (existing measurement) ----------------------------- */
+
+
+struct inst *find_point_meas_move(struct inst *inst, struct coord pos)
+{
+        return inst_find_vec(pos, meas_pick_vec_b, meas_inst);
+}
+
+
+/* ----- end dragging existing measurements -------------------------------- */
+
+
+void end_drag_move_meas(void)
+{
+        highlight = NULL;
         redraw();
 }
 
 
-/* ----- operations ------------------------------------------------------- */
+void do_move_to_meas(struct inst *inst, struct inst *to, int i)
+{
+        struct meas *meas = &inst->obj->u.meas;
+
+        switch (i) {
+        case 0:
+                inst->obj->base = inst_get_vec(to);
+                break;
+        case 1:
+                meas->high = inst_get_vec(to);
+                if (is_max(meas_dsc->lt, to))
+                        meas->type = (meas->type % 3)+3;
+                else
+                        meas->type = (meas->type % 3);
+                break;
+        default:
+                abort();
+        }
+}
+
+
+/* ----- operations -------------------------------------------------------- */
 
 
@@ -351 +425 @@
         .tool_selected  = tool_selected_meas_xy,
         .tool_deselected= tool_deselected_meas,
-        .find_point     = find_point_meas,
+        .find_point     = find_point_meas_new,
         .begin_drag_new = begin_drag_new_meas,
         .drag_new       = drag_new_line,
         .end_new        = end_new_meas,
+        .cancel_drag_new= cancel_drag_new_meas,
 };
 
@@ -360 +435 @@
         .tool_selected  = tool_selected_meas_x,
         .tool_deselected= tool_deselected_meas,
-        .find_point     = find_point_meas,
+        .find_point     = find_point_meas_new,
         .begin_drag_new = begin_drag_new_meas,
         .drag_new       = drag_new_line,
         .end_new        = end_new_meas,
+        .cancel_drag_new= cancel_drag_new_meas,
 };
 
@@ -370 +446 @@
         .tool_selected  = tool_selected_meas_y,
         .tool_deselected= tool_deselected_meas,
-        .find_point     = find_point_meas,
+        .find_point     = find_point_meas_new,
         .begin_drag_new = begin_drag_new_meas,
         .drag_new       = drag_new_line,
         .end_new        = end_new_meas,
-};
+        .cancel_drag_new= cancel_drag_new_meas,
+};

trunk/eda/fped/gui_meas.h

@@ -24 +24 @@
 
 void begin_drag_move_meas(struct inst *inst, int i);
+struct inst *find_point_meas_move(struct inst *inst, struct coord pos);
+void end_drag_move_meas(void);
+void do_move_to_meas(struct inst *inst, struct inst *to, int i);
 
 #endif /* !GUI_MEAS_H */

trunk/eda/fped/gui_tool.c

@@ -458 +458 @@
 
 
-void do_move_to_arc(struct inst *inst, struct vec *vec, int i)
-{
+void do_move_to_arc(struct inst *inst, struct inst *to, int i)
+{
+        struct vec *vec = inst_get_vec(to);
         struct obj *obj = inst->obj;
         int is_circle;
@@ -592 +593 @@
 
 
+#if 0
 static int may_move(struct inst *curr)
 {
@@ -606 +608 @@
         return 0;
 }
+#endif
 
 
@@ -643 +646 @@
 static void do_move_to(struct drag_state *state, struct inst *curr)
 {
-        assert(may_move_to(state, curr));
+        assert(state->inst->ops->find_point || may_move_to(state, curr));
         *state->anchors[state->anchor_i] = inst_get_vec(curr);
 }
@@ -666 +669 @@
 
 
+/*
+ * When hovering, we have to consider the following states:
+ *
+ * selected (selected_inst != NULL)
+ * |  dragging new (drag.new != NULL)
+ * |  |  dragging existing (drag.anchors_n != 0)
+ * |  |  |  tool selected (active_ops)
+ * |  |  |  |
+ * Y  N  N  N  highlight if inst_find_point_selected else don't
+ * Y  N  N  Y  highlight if inst_find_point_selected else fall over to tool
+ * -  Y  N  -  highlight if inst_find_point / active_ops->find_point else don't
+ * -  N  Y  -  highlight if may_move_to else don't
+ * -  Y  Y  -  invalid state
+ * N  N  N  Y  highlight if inst_find_point / active_ops->find_point else don't
+ * N  N  N  N  don't highlight
+ */
+
+static struct inst *get_hover_inst(struct coord pos)
+{
+        struct inst *inst;
+        int i;
+
+        if (drag.new) {
+                if (active_ops->find_point)
+                        return active_ops->find_point(pos);
+                return inst_find_point(pos);
+        }
+        if (drag.anchors_n) {
+                if (drag.inst->ops->find_point)
+                        return drag.inst->ops->find_point(drag.inst, pos);
+                inst = inst_find_point(pos);
+                if (!inst)
+                        return NULL;
+                return may_move_to(&drag, inst) ? inst : NULL;
+        }
+        if (selected_inst) {
+                i = inst_find_point_selected(pos, &inst);
+                if (i != -1)
+                        return inst;
+        }
+        if (!active_ops)
+                return NULL;
+        if (active_ops->find_point)
+                return active_ops->find_point(pos);
+        return inst_find_point(pos);
+}
+
+
 void tool_hover(struct coord pos)
 {
-        struct inst *curr;
-
-        if (active_ops && active_ops->find_point)
-                curr = active_ops->find_point(pos);
-        else
-                curr = inst_find_point(pos);
+        struct inst *curr = NULL;
+
+        curr = get_hover_inst(pos);
+#if 0
         if ((drag.new && curr == drag.new) || (drag.inst && curr == drag.inst))
                 return;
@@ -686 +735 @@
                 }
         }
+got:
+#endif
+
         if (curr == hover_inst)
                 return;
@@ -713 +765 @@
 
 
+/*
+ * When considering dragging, we have the following states:
+ *
+ * selected (selected_inst != NULL)
+ * |  tool selected (active_ops)
+ * |  |
+ * N  N  don't
+ * Y  -  if we could drag, drag_new/end_new, else fall over to tool
+ * N  Y  click, else single-click creation, else drag_new/end_new
+ */
+
 int tool_consider_drag(struct coord pos)
 {
@@ -720 +783 @@
         assert(!drag.anchors_n);
         last_canvas_pos = translate(pos);
-        if (active_ops && active_ops->click) {
+
+        if (!selected_inst && !active_ops)
+                return 0;
+        if (selected_inst) {
+                drag.anchor_i = inst_find_point_selected(pos, NULL);
+                if (drag.anchor_i != -1) {
+                        tool_dehover();
+                        drag.inst = selected_inst;
+                        drag.new = NULL;
+                        drag.anchors_n =
+                            inst_anchors(selected_inst, drag.anchors);
+                        over_begin(drag_save_and_draw, NULL, pos);
+                        inst_begin_drag_move(selected_inst, drag.anchor_i);
+                        return 1;
+                }
+        }
+        if (!active_ops)
+                return 0;
+        if (active_ops->click) {
                 active_ops->click(pos);
                 return 0;
         }
-        if (active_ops && active_ops->find_point)
-                curr = active_ops->find_point(pos);
-        else
-                curr = inst_find_point(pos);
+
+        curr = get_hover_inst(pos);
         if (!curr)
                 return 0;
+
         tool_dehover();
-        if (active_ops) {
-                if (active_ops->drag_new) {
-                        if (active_ops->begin_drag_new)
-                                active_ops->begin_drag_new(curr);
-                        drag.inst = NULL;
-                        drag.new = curr;
-                        over_begin(drag_save_and_draw, NULL, pos);
-                        return 1;
-                } else {
-                        /* object is created without dragging */
-                        if (active_ops->end_new(curr, NULL)) {
-                                tool_cancel_drag();
-                                return -1;
-                        }
-                        return 0;
-                }
-        }
-        if (!may_move(curr))
-                return 0;
-        drag.inst = selected_inst;
-        drag.new = NULL;
-        inst_begin_drag_move(selected_inst, drag.anchor_i);
-        over_begin(drag_save_and_draw, NULL, pos);
-        return 1;
+
+        if (active_ops->drag_new) {
+                if (active_ops->begin_drag_new)
+                        active_ops->begin_drag_new(curr);
+                drag.inst = NULL;
+                drag.new = curr;
+                over_begin(drag_save_and_draw, NULL, pos);
+                return 1;
+        }
+
+        /* object is created without dragging */
+        if (active_ops->end_new(curr, NULL)) {
+                tool_cancel_drag();
+                return -1;
+        }
+        return 0;
+
 }
 
@@ -767 +840 @@
 void tool_cancel_drag(void)
 {
+        if (drag.anchors_n && drag.inst->ops->end_drag_move)
+        if (drag.anchors_n && drag.inst->ops->end_drag_move)
+                drag.inst->ops->end_drag_move();
+        drag.new = NULL;
+        active_ops = NULL;
+        drag.anchors_n = 0;
         over_end();
         tool_dehover();
         tool_reset();
-        drag.new = NULL;
-        active_ops = NULL;
-        drag.anchors_n = 0;
 }
 
@@ -785 +861 @@
         if (state.new && ops->end_new_raw)
                 return ops->end_new_raw(state.new, to);
-        if (ops->find_point)
+        if (state.new && ops->find_point)
                 end = ops->find_point(to);
-        else
-                end = inst_find_point(to);
-        if (!end)
-                return 0;
+        else {
+                if (state.inst && state.inst->ops->find_point)
+                        end = state.inst->ops->find_point(state.inst, to);
+                else
+                        end = inst_find_point(to);
+        }
+        if (!end) {
+                if (state.new && ops->cancel_drag_new)
+                        ops->cancel_drag_new();
+                return 0;
+        }
         if (state.new)
                 return ops->end_new(state.new, end);
-        if (!may_move_to(&state, end))
-                return 0;
-        if (!inst_do_move_to(drag.inst, inst_get_vec(end), state.anchor_i))
+
+        /* if we got the point from find_point, it's authoritative */
+        if (!state.inst->ops->find_point && !may_move_to(&state, end))
+                return 0;
+        if (!inst_do_move_to(state.inst, end, state.anchor_i))
                 do_move_to(&state, end);
         return 1;
@@ -803 +888 @@
 void tool_redraw(void)
 {
+        struct coord pos;
+
         over_reset();
+        hover_inst = NULL;
         if (!drag.new && !drag.anchors_n)
                 return;
-        tool_hover(last_canvas_pos);
-        over_begin(drag_save_and_draw, NULL,
-            canvas_to_coord(last_canvas_pos.x, last_canvas_pos.y));
+        pos = canvas_to_coord(last_canvas_pos.x, last_canvas_pos.y);
+        tool_hover(pos);
+        over_begin(drag_save_and_draw, NULL, pos);
 }
 
@@ -838 +926 @@
 {
         over_reset();
+        hover_inst = NULL;
         tool_select(ev_point, NULL);
 }

trunk/eda/fped/gui_tool.h

@@ -29 +29 @@
         int (*end_new_raw)(struct inst *from, struct coord to);
         int (*end_new)(struct inst *from, struct inst *to);
+        void (*cancel_drag_new)(void);
 };
 
@@ -43 +44 @@
 struct pix_buf *gui_hover_frame(struct inst *self);
 
-void do_move_to_arc(struct inst *inst, struct vec *vec, int i);
+void do_move_to_arc(struct inst *inst, struct inst *to, int i);
 
 void tool_dehover(void);

trunk/eda/fped/inst.c

@@ -29 +29 @@
 #include "inst.h"
 
-
-struct inst_ops {
-        void (*debug)(struct inst *self);
-        void (*save)(FILE *file, struct inst *self);
-        void (*draw)(struct inst *self);
-        struct pix_buf *(*hover)(struct inst *self);
-        unit_type (*distance)(struct inst *self, struct coord pos, 
-            unit_type scale);
-        void (*select)(struct inst *self);
-        int (*anchors)(struct inst *self, struct vec ***anchors);
-        void (*begin_drag_move)(struct inst *from, int i);
-        struct pix_buf *(*draw_move)(struct inst *inst,
-            struct coord pos, int i);
-        /* arcs and measurements need this special override */
-        void (*do_move_to)(struct inst *inst, struct vec *vec, int i);
-};
 
 enum inst_prio {
@@ -236 +220 @@
 
 
+int inst_find_point_selected(struct coord pos, struct inst **res)
+{
+        struct vec **anchors[3];
+        int n, best_i, i;
+        struct inst *best = NULL;
+        struct inst *inst;
+        int d_min, d;
+
+        assert(selected_inst);
+        n = inst_anchors(selected_inst, anchors);
+        for (i = 0; i != n; i++) {
+                if (*anchors[i]) {
+                        for (inst = insts[ip_vec]; inst; inst = inst->next) {
+                                if (inst->vec != *anchors[i])
+                                        continue;
+                                d = gui_dist_vec(inst, pos, draw_ctx.scale);
+                                if (d != -1 && (!best || d < d_min)) {
+                                        best = inst;
+                                        best_i = i;
+                                        d_min = d;
+                                }
+                        }
+                } else {
+                        for (inst = insts[ip_frame]; inst; inst = inst->next) {
+                                if (inst != selected_inst->outer)
+                                        continue;
+                                d = gui_dist_frame(inst, pos, draw_ctx.scale);
+                                if (d != -1 && (!best || d < d_min)) {
+                                        best = inst;
+                                        best_i = i;
+                                        d_min = d;
+                                }
+                        }
+                }
+        }
+        if (!best)
+                return -1;
+        if (res)
+                *res = best;
+        return best_i;
+}
+
+
 struct coord inst_get_point(const struct inst *inst)
 {
@@ -318 +345 @@
 static void propagate_bbox(const struct inst *inst)
 {
-        /* @@@ for new-style measurements */
         struct inst *frame = curr_frame ? curr_frame : insts[ip_frame];
 
@@ -389 +415 @@
 
 
+/*
+ * @@@ The logic of gui_find_point_vec isn't great. Instead of selecting a
+ * point and then filtering, we should filter the candidates, so that a point
+ * that's close end eligible can win against one that's closer but not
+ * eligible.
+ */
+
+static struct inst *find_point_vec(struct inst *self, struct coord pos)
+{
+        struct inst *inst;
+        const struct vec *vec;
+
+        inst = inst_find_point(pos);
+        if (!inst)
+                return NULL;
+        if (inst->ops == &frame_ops)
+                return inst;
+        for (vec = inst->vec; vec; vec = vec->base)
+                if (vec == self->vec)
+                return NULL;
+        return inst;
+}
+
+
 static int vec_op_anchors(struct inst *inst, struct vec ***anchors)
 {
@@ -402 +452 @@
         .distance       = gui_dist_vec,
         .select         = vec_op_select,
+        .find_point     = find_point_vec,
         .anchors        = vec_op_anchors,
         .draw_move      = draw_move_vec,
@@ -670 +721 @@
         status_set_type_entry("offset =");
         status_set_name("%5.2f mm", units_to_mm(self->u.meas.offset));
-        if (!self->obj)
-                return; /* @@@ new-style measurements */
         edit_expr(&self->obj->u.meas.offset);
 }
@@ -693 +742 @@
         .anchors        = meas_op_anchors,
         .begin_drag_move= begin_drag_move_meas,
+        .find_point     = find_point_meas_move,
         .draw_move      = draw_move_meas,
+        .end_drag_move  = end_drag_move_meas,
+        .do_move_to     = do_move_to_meas,
 };
 
@@ -912 +964 @@
 
 
-int inst_do_move_to(struct inst *inst, struct vec *vec, int i)
+int inst_do_move_to(struct inst *inst, struct inst *to, int i)
 {
         if (!inst->ops->do_move_to)
                 return 0;
-        inst->ops->do_move_to(inst, vec, i);
+        inst->ops->do_move_to(inst, to, i);
         return 1;
 }

trunk/eda/fped/inst.h

@@ -37 +37 @@
 };
 
-struct inst_ops;
+struct inst;
+
+struct inst_ops {
+        void (*debug)(struct inst *self);
+        void (*save)(FILE *file, struct inst *self);
+        void (*draw)(struct inst *self);
+        struct pix_buf *(*hover)(struct inst *self);
+        unit_type (*distance)(struct inst *self, struct coord pos, 
+            unit_type scale);
+        void (*select)(struct inst *self);
+        int (*anchors)(struct inst *self, struct vec ***anchors);
+        void (*begin_drag_move)(struct inst *from, int i);
+        struct inst *(*find_point)(struct inst *self, struct coord pos);
+        struct pix_buf *(*draw_move)(struct inst *inst,
+            struct coord pos, int i);
+        void (*end_drag_move)(void);
+        /* arcs and measurements need this special override */
+        void (*do_move_to)(struct inst *inst, struct inst *to, int i);
+};
 
 struct inst {
@@ -86 +104 @@
 
 struct inst *inst_find_point(struct coord pos);
+int inst_find_point_selected(struct coord pos, struct inst **res);
 struct coord inst_get_point(const struct inst *inst);
 int inst_anchors(struct inst *inst, struct vec ***anchors);
@@ -120 +139 @@
 
 struct pix_buf *inst_draw_move(struct inst *inst, struct coord pos, int i);
-int inst_do_move_to(struct inst *inst, struct vec *vec, int i);
+int inst_do_move_to(struct inst *inst, struct inst *to, int i);
 struct pix_buf *inst_hover(struct inst *inst);
 void inst_begin_drag_move(struct inst *inst, int i);

trunk/eda/fped/meas.c

@@ -24 +24 @@
 struct num eval_unit(const struct expr *expr, const struct frame *frame);
 
-struct sample {
-        struct coord pos;
-        struct sample *next;
-};
-
 
 static void reset_samples(struct sample **samples)

trunk/eda/fped/meas.h

@@ -42 +42 @@
 };
 
-struct sample;
+struct sample {
+        struct coord pos;
+        struct sample *next;
+};