home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume8 / xfig2.8 / part13 / movept.c < prev    next >
C/C++ Source or Header  |  1990-07-03  |  17KB  |  691 lines
  1. /* 
  2.  *    FIG : Facility for Interactive Generation of figures
  3.  *
  4.  *    Copyright (c) 1985 by Supoj Sutanthavibul (supoj@sally.UTEXAS.EDU)
  5.  *    January 1985.
  6.  *    1st revision : Aug 1985.
  7.  *
  8.  *    %W%    %G%
  9. */
  10. #include "fig.h"
  11. #include "resources.h"
  12. #include "func.h"
  13. #include "object.h"
  14. #include "paintop.h"
  15.  
  16. #define            TOLERANCE    3
  17. extern int        latexline_mode, latexarrow_mode;
  18. extern int        magnet_mode;
  19.  
  20. extern            (*canvas_kbd_proc)();
  21. extern            (*canvas_locmove_proc)();
  22. extern            (*canvas_leftbut_proc)();
  23. extern            (*canvas_middlebut_proc)();
  24. extern            (*canvas_rightbut_proc)();
  25. extern            null_proc();
  26. extern            set_popupmenu();
  27. F_line            *line_point_search();
  28. F_spline        *spline_point_search();
  29. F_ellipse        *ellipse_point_search();
  30. F_arc            *arc_point_search();
  31.  
  32. extern F_compound    objects;
  33.  
  34. extern F_point        *moved_point, *left_point;
  35. extern F_pos        last_position, new_position;
  36. extern int        movedpoint_num;
  37. extern int        last_object;
  38. extern int        fix_x, fix_y, cur_x, cur_y;
  39. extern int        pointmarker_shown;
  40. extern int        foreground_color, background_color;
  41.  
  42. extern            elastic_box(), move_ebrbox(), move_ebdbox();
  43. extern            move_cbrbox(), move_cbdbox();
  44.  
  45. extern int        init_move_point();
  46. extern int        move_linepoint(), fix_movedlinepoint();
  47. extern int        move_latexlinepoint(), fix_movedlatexlinepoint();
  48. extern int        fix_box();
  49. extern int        fix_movedsplinepoint();
  50. extern int        move_arcpoint(), fix_movedarcpoint();
  51. extern int        fix_movedellipsepoint();
  52.  
  53. static F_line        *line;
  54. static F_spline        *spline;
  55. static F_ellipse    *ellipse;
  56. static F_arc        *arc;
  57.  
  58. static int        latex_fix_x, latex_fix_y;
  59. CURSOR            cur_latexcursor;
  60. Boolean            init_ellipsepointmoving();
  61.  
  62. move_point_selected()
  63. {
  64.     canvas_kbd_proc = null_proc;
  65.     canvas_locmove_proc = null_proc;
  66.     canvas_leftbut_proc = init_move_point;
  67.     canvas_middlebut_proc = null_proc;
  68.     canvas_rightbut_proc = set_popupmenu;
  69.     set_cursor(&pick9_cursor);
  70.     reset_action_on();
  71.     }
  72.  
  73. init_move_point(x, y)
  74. int    x, y;
  75. {
  76.     Boolean Ok=True;
  77.  
  78.     if ((line = line_point_search(x, y, TOLERANCE,
  79.         &left_point, &moved_point)) != NULL) {
  80.         init_linepointmoving(line);
  81.         }
  82.     else if ((spline = spline_point_search(x, y, 
  83.         TOLERANCE, &left_point, &moved_point)) != NULL){
  84.         init_splinepointmoving(spline);
  85.         }
  86.     else if ((ellipse = ellipse_point_search(x, y, TOLERANCE, 
  87.         &movedpoint_num)) != NULL) {
  88.         if (!init_ellipsepointmoving(ellipse))    /* selected center, ignore */
  89.         Ok=False;
  90.         }
  91.     else if ((arc = arc_point_search(x, y, TOLERANCE, 
  92.         &movedpoint_num)) != NULL) {
  93.         init_arcpointmoving(arc);
  94.         }
  95.     else {
  96.         return;
  97.         }
  98.     if (Ok)        /* movepoint went ok */
  99.         {
  100.         canvas_leftbut_proc = canvas_rightbut_proc = null_proc;
  101.         erase_pointmarker();
  102.         }
  103.     }
  104.  
  105. wrapup_movepoint()
  106. {
  107.     show_pointmarker();
  108.     move_point_selected();
  109.     }
  110.  
  111. /*************************  ellipse  *******************************/
  112.  
  113. F_ellipse *
  114. ellipse_point_search(x, y, tol, point_num)
  115. int    x, y, tol, *point_num;
  116. {
  117.     F_ellipse    *e;
  118.  
  119.     for (e = objects.ellipses; e != NULL; e = e->next) {
  120.         if (abs(e->start.x - x) <= tol && abs(e->start.y - y) <= tol) {
  121.         *point_num = 0;
  122.         return(e);
  123.         }
  124.         if (abs(e->end.x - x) <= tol && abs(e->end.y - y) <= tol) {
  125.         *point_num = 1;
  126.         return(e);
  127.         }
  128.         }
  129.     return(NULL);
  130.     }
  131.  
  132. static F_ellipse    *cur_e;
  133.  
  134. Boolean
  135. init_ellipsepointmoving(ellipse)
  136. F_ellipse    *ellipse;
  137. {
  138.     if (movedpoint_num == 0) {  /*  center point is selected - disallow */
  139.         if (ellipse->type == T_ELLIPSE_BY_RAD || 
  140.         ellipse->type == T_CIRCLE_BY_RAD) {
  141.         return False;    /* don't erase point_marker etc */
  142.         }
  143.         last_position.x = cur_x = ellipse->start.x;
  144.         last_position.y = cur_y = ellipse->start.y;
  145.         fix_x = ellipse->end.x;  fix_y = ellipse->end.y;
  146.         switch (ellipse->type) {
  147.         case T_ELLIPSE_BY_DIA :
  148.             canvas_locmove_proc = move_ebdbox;
  149.             ellipsebydia_box(INV_PAINT);
  150.             break;
  151.         case T_CIRCLE_BY_DIA :
  152.             canvas_locmove_proc = move_cbdbox;
  153.             circlebydia_box(INV_PAINT);
  154.             break;
  155.         }
  156.         }
  157.     else {
  158.         last_position.x = cur_x = ellipse->end.x;
  159.         last_position.y = cur_y = ellipse->end.y;
  160.         fix_x = ellipse->start.x;  fix_y = ellipse->start.y;
  161.         switch (ellipse->type) {
  162.         case T_ELLIPSE_BY_RAD :
  163.             canvas_locmove_proc = move_ebrbox;
  164.             ellipsebyrad_box(INV_PAINT);
  165.             break;
  166.         case T_CIRCLE_BY_RAD :
  167.             canvas_locmove_proc = move_cbrbox;
  168.             circlebyrad_box(INV_PAINT);
  169.             break;
  170.         case T_ELLIPSE_BY_DIA :
  171.             canvas_locmove_proc = move_ebdbox;
  172.             ellipsebydia_box(INV_PAINT);
  173.             break;
  174.         case T_CIRCLE_BY_DIA :
  175.             canvas_locmove_proc = move_cbdbox;
  176.             circlebydia_box(INV_PAINT);
  177.             break;
  178.         }
  179.         }
  180.     cur_e = ellipse;
  181.     set_temp_cursor(&crosshair_cursor);
  182.     win_setmouseposition(canvas_win, cur_x, cur_y);
  183.     canvas_middlebut_proc = fix_movedellipsepoint;
  184.     canvas_leftbut_proc = null_proc;
  185.     return True;    /* all is Ok */
  186.     }
  187.  
  188. fix_movedellipsepoint(x, y)
  189. int    x, y;
  190. {
  191.     switch (cur_e->type) {
  192.         case T_ELLIPSE_BY_RAD :
  193.         ellipsebyrad_box(INV_PAINT);
  194.         break;
  195.         case T_CIRCLE_BY_RAD :
  196.         circlebyrad_box(INV_PAINT);
  197.         break;
  198.         case T_ELLIPSE_BY_DIA :
  199.         ellipsebydia_box(INV_PAINT);
  200.         break;
  201.         case T_CIRCLE_BY_DIA :
  202.         circlebydia_box(INV_PAINT);
  203.         break;
  204.         }
  205.     new_position.x = x;
  206.     new_position.y = y;
  207.     clean_up();
  208.     set_action_object(F_MOVE_POINT, O_ELLIPSE);
  209.     set_latestellipse(cur_e);
  210.     relocate_ellipsepoint(cur_e, x, y, movedpoint_num);
  211.     wrapup_movepoint();
  212.     }
  213.  
  214. relocate_ellipsepoint(ellipse, x, y, point_num)
  215. F_ellipse    *ellipse;
  216. int        x, y, point_num;
  217. {
  218.     int    dx, dy;
  219.  
  220.     set_temp_cursor(&wait_cursor);
  221.     if (pointmarker_shown) toggle_ellipsepointmarker(ellipse);
  222.     draw_ellipse(ellipse, background_color);
  223.     if (point_num == 0) {  /*  starting point is selected  */
  224.         fix_x = ellipse->end.x;  fix_y = ellipse->end.y;
  225.         ellipse->start.x = x;  ellipse->start.y = y;
  226.         }
  227.     else {
  228.         fix_x = ellipse->start.x;  fix_y = ellipse->start.y;
  229.         ellipse->end.x = x;  ellipse->end.y = y;
  230.         }
  231.     switch (ellipse->type) {
  232.         case T_ELLIPSE_BY_RAD :
  233.         ellipse->radiuses.x = abs(x - fix_x) + 1;
  234.         ellipse->radiuses.y = abs(y - fix_y) + 1;
  235.         break;
  236.         case T_CIRCLE_BY_RAD :
  237.         dx = fix_x - x;  dy = fix_y - y;
  238.         ellipse->radiuses.x = sqrt((double)(dx*dx + dy*dy)) + .5;
  239.         ellipse->radiuses.y = ellipse->radiuses.x;
  240.         break;
  241.         case T_ELLIPSE_BY_DIA :
  242.         ellipse->center.x = (fix_x + x) / 2;
  243.         ellipse->center.y = (fix_y + y) / 2;
  244.         ellipse->radiuses.x = abs(ellipse->center.x - fix_x);
  245.         ellipse->radiuses.y = abs(ellipse->center.y - fix_y);
  246.         break;
  247.         case T_CIRCLE_BY_DIA :
  248.         dx = ellipse->center.x = (fix_x + x) / 2 +.5;
  249.         dy = ellipse->center.y = (fix_y + y) / 2 +.5;
  250.         dx -= x;  dy -= y; 
  251.         ellipse->radiuses.x = sqrt((double)(dx*dx + dy*dy)) + .5;
  252.         ellipse->radiuses.y = ellipse->radiuses.x;
  253.         break;
  254.         }
  255.     draw_ellipse(ellipse, foreground_color);
  256.     if (pointmarker_shown) toggle_ellipsepointmarker(ellipse);
  257.     reset_cursor();
  258.     set_modifiedflag();
  259.     }
  260.  
  261. /***************************  arc  *********************************/
  262.  
  263. static F_arc        *cur_a;
  264.  
  265. F_arc *
  266. arc_point_search(x, y, tol, point_num)
  267. int    x, y, tol, *point_num;
  268. {
  269.     F_arc    *a;
  270.     int    i;
  271.  
  272.     for(a = objects.arcs; a != NULL; a = a->next) {
  273.         for (i = 0; i < 3; i++) {
  274.         if (abs(a->point[i].x - x) <= tol && 
  275.             abs(a->point[i].y - y) <= tol) {
  276.             *point_num = i;
  277.             return(a);
  278.             }
  279.         }
  280.         }
  281.     return(NULL);
  282.     }
  283.  
  284. init_arcpointmoving(arc)
  285. F_arc    *arc;
  286. {
  287.     cur_a = arc;
  288.     last_position.x = cur_x = arc->point[movedpoint_num].x;
  289.     last_position.y = cur_y = arc->point[movedpoint_num].y;
  290.     set_temp_cursor(&crosshair_cursor);
  291.     win_setmouseposition(canvas_win, cur_x, cur_y);
  292.     draw_arclink(INV_PAINT);
  293.     canvas_locmove_proc = move_arcpoint;
  294.     canvas_middlebut_proc = fix_movedarcpoint;
  295.     canvas_leftbut_proc = null_proc;
  296.     }
  297.  
  298. move_arcpoint(x, y)
  299. int    x, y;
  300. {
  301.     draw_arclink(INV_PAINT);
  302.     cur_x = x;  cur_y = y;
  303.     draw_arclink(INV_PAINT);
  304.     }
  305.  
  306. draw_arclink(op)
  307. int    op;
  308. {
  309.     switch (movedpoint_num) {
  310.         case 0 :
  311.         pw_vector(canvas_win, cur_x, cur_y, 
  312.             arc->point[1].x, arc->point[1].y, op, 1, SOLID_LINE, 0.0);
  313.         break;
  314.         case 1 :
  315.         pw_vector(canvas_win, arc->point[0].x, arc->point[0].y,
  316.             cur_x, cur_y, op, 1, SOLID_LINE, 0.0);
  317.         pw_vector(canvas_win, arc->point[2].x, arc->point[2].y,
  318.             cur_x, cur_y, op, 1, SOLID_LINE, 0.0);
  319.         break;
  320.         default :
  321.         pw_vector(canvas_win, arc->point[2].x, arc->point[2].y,
  322.             cur_x, cur_y, op, 1, SOLID_LINE, 0.0);
  323.         }
  324.     }
  325.  
  326. fix_movedarcpoint(x, y)
  327. int    x, y;
  328. {
  329.     draw_arclink(INV_PAINT);
  330.     new_position.x = x;
  331.     new_position.y = y;
  332.     clean_up();
  333.     set_action_object(F_MOVE_POINT, O_ARC);
  334.     set_latestarc(cur_a);
  335.     relocate_arcpoint(cur_a, x, y, movedpoint_num);
  336.     wrapup_movepoint();
  337.     }
  338.  
  339. relocate_arcpoint(arc, x, y, movedpoint_num)
  340. F_arc    *arc;
  341. int             x, y, movedpoint_num;
  342. {
  343.     float    xx, yy;
  344.     F_pos    p[3];
  345.  
  346.     p[0] = arc->point[0];
  347.     p[1] = arc->point[1];
  348.     p[2] = arc->point[2];
  349.     p[movedpoint_num].x = x;
  350.     p[movedpoint_num].y = y;
  351.     if (compute_arccenter(p[0], p[1], p[2], &xx, &yy)) {
  352.         set_temp_cursor(&wait_cursor);
  353.         if (pointmarker_shown) toggle_arcpointmarker(arc);
  354.         draw_arc(arc, background_color);    /* erase old arc */
  355.         arc->point[movedpoint_num].x = x;
  356.         arc->point[movedpoint_num].y = y;
  357.         arc->center.x = xx;
  358.         arc->center.y = yy;
  359.         arc->direction = compute_direction(p[0], p[1], p[2]);
  360.         draw_arc(arc, foreground_color);    /* draw new arc */
  361.         if (pointmarker_shown) toggle_arcpointmarker(arc);
  362.         reset_cursor();
  363.         set_modifiedflag();
  364.         }
  365.     }
  366.  
  367. /**************************  spline  *******************************/
  368.  
  369. static F_spline        *cur_s;
  370.  
  371. init_splinepointmoving(s)
  372. F_spline    *s;
  373. {
  374.     F_point    *p;
  375.  
  376.     cur_s = s;
  377.     last_position.x = cur_x = moved_point->x;
  378.     last_position.y = cur_y = moved_point->y;
  379.     set_temp_cursor(&crosshair_cursor);
  380.     win_setmouseposition(canvas_win, cur_x, cur_y);
  381.     if (closed_spline(s) && left_point == NULL) {
  382.         for (left_point = moved_point->next, 
  383.         p = left_point->next; 
  384.         p->next != NULL; 
  385.         left_point = p, p = p->next);
  386.         }
  387.     draw_pointlink(INV_PAINT);
  388.     canvas_locmove_proc = move_linepoint;
  389.     canvas_middlebut_proc = fix_movedsplinepoint;
  390.     canvas_leftbut_proc = null_proc;
  391.     }
  392.  
  393. F_spline *
  394. spline_point_search(x, y, tol, p, q)
  395. int    x, y, tol;
  396. F_point    **p, **q;
  397. {
  398.     F_spline    *s;
  399.  
  400.     for (s = objects.splines; s != NULL; s= s->next) {
  401.         *p = NULL;
  402.         for (*q = s->points; *q != NULL; *p = *q, *q = (*q)->next) {
  403.         if (abs((*q)->x - x) <= tol && abs((*q)->y - y) <= tol)
  404.             return(s);
  405.         }
  406.         }
  407.     return(NULL);
  408.     }
  409.  
  410. fix_movedsplinepoint(x, y)
  411. int    x, y;
  412. {
  413.     draw_pointlink(INV_PAINT);
  414.     new_position.x = x;
  415.     new_position.y = y;
  416.     clean_up();
  417.     set_action_object(F_MOVE_POINT, O_SPLINE);
  418.     set_latestspline(cur_s);
  419.     relocate_splinepoint(cur_s, x, y, moved_point);
  420.     wrapup_movepoint();
  421.     }
  422.  
  423. relocate_splinepoint(s, x, y, moved_point)
  424. F_spline    *s;
  425. int        x, y;
  426. F_point        *moved_point;
  427. {
  428.     set_temp_cursor(&wait_cursor);
  429.     if (pointmarker_shown) toggle_splinepointmarker(s);  
  430.     draw_spline(s, ERASE); /* erase old spline */
  431.     moved_point->x = x;
  432.     moved_point->y = y;
  433.     if (closed_spline(s)) {
  434.         left_point->next->x = x;
  435.         left_point->next->y = y;
  436.         }
  437.     if (int_spline(s)) remake_control_points(s);
  438.     draw_spline(s, PAINT); /* draw spline with moved point */
  439.     if (pointmarker_shown) toggle_splinepointmarker(s);  
  440.     reset_cursor();
  441.     set_modifiedflag();
  442.     }
  443.  
  444. /***************************  line  ********************************/
  445.  
  446. static F_line        *cur_l;
  447.  
  448. init_linepointmoving(line)
  449. F_line    *line;
  450. {
  451.     int    box_case;
  452.     int    latex_case;
  453.     F_point    *p;
  454.  
  455.     cur_l = line;
  456.     box_case = 0;
  457.     latex_case = 0;
  458.     last_position.x = cur_x = moved_point->x;
  459.     last_position.y = cur_y = moved_point->y;
  460.     set_temp_cursor(&crosshair_cursor);
  461.     win_setmouseposition(canvas_win, cur_x, cur_y);
  462.     switch (line->type) {
  463.         case T_POLYGON :
  464.         if (left_point == NULL)
  465.             for (left_point = moved_point->next, 
  466.             p = left_point->next; 
  467.             p->next != NULL; 
  468.             left_point = p, p = p->next);
  469.         break;
  470.         case T_BOX :
  471.         case T_ARC_BOX :
  472.         if (moved_point->next->next == NULL) { /* point 4 */
  473.             fix_x = line->points->next->x;
  474.             fix_y = line->points->next->y;
  475.             }
  476.         else {
  477.             fix_x = moved_point->next->next->x;
  478.             fix_y = moved_point->next->next->y;
  479.             }
  480.         if (line->type == T_ARC_BOX)
  481.             draw_arc_box(line, ERASE);
  482.         else
  483.             draw_line(line, ERASE);
  484.         box_case = 1;
  485.         break;
  486.         case T_POLYLINE :
  487.         if (left_point != NULL) {
  488.             if (left_point == line->points) {
  489.             if (line->back_arrow) /*  backward arrow  */
  490.                 draw_arrow(cur_x, cur_y,
  491.                 left_point->x, left_point->y,
  492.                 line->back_arrow, ERASE);
  493.             }
  494.             }
  495.         else if (line->back_arrow) /*  backward arrow  */
  496.             draw_arrow(moved_point->next->x, moved_point->next->y,
  497.             cur_x, cur_y, line->back_arrow, ERASE);
  498.         p = moved_point->next;
  499.         if (p != NULL) {
  500.             if (line->for_arrow && p->next == NULL) 
  501.             draw_arrow(cur_x, cur_y, p->x, p->y, 
  502.                 line->for_arrow, ERASE);
  503.             }
  504.         else if (line->for_arrow)/* f arrow */
  505.             draw_arrow(left_point->x, left_point->y, 
  506.             cur_x, cur_y, line->for_arrow, ERASE);
  507.         if (latexline_mode || latexarrow_mode) {
  508.             if (left_point != NULL) {
  509.             latex_fix_x = left_point->x;
  510.             latex_fix_y = left_point->y;
  511.             latex_case = 1;
  512.             }
  513.             else if (p != NULL) {
  514.             latex_fix_x = p->x;
  515.             latex_fix_y = p->y;
  516.             latex_case = 1;
  517.             }
  518.             }
  519.         }
  520.     if (box_case) {
  521.         draw_rectbox(fix_x, fix_y, cur_x, cur_y, INV_PAINT);
  522.         canvas_locmove_proc = elastic_box;
  523.         canvas_middlebut_proc = fix_box;
  524.         }
  525.     else if (latex_case) {
  526.         draw_pointlink(INV_PAINT);
  527.         canvas_locmove_proc = move_latexlinepoint;
  528.         canvas_middlebut_proc = fix_movedlatexlinepoint;
  529.         cur_latexcursor = &crosshair_cursor;
  530.         }
  531.     else {
  532.         draw_pointlink(INV_PAINT);
  533.         canvas_locmove_proc = move_linepoint;
  534.         canvas_middlebut_proc = fix_movedlinepoint;
  535.         }
  536.     canvas_leftbut_proc = null_proc;
  537.     }
  538.  
  539. move_linepoint(x, y)
  540. int    x, y;
  541. {
  542.     draw_pointlink(INV_PAINT);
  543.     cur_x = x;
  544.     cur_y = y;
  545.     draw_pointlink(INV_PAINT);
  546.     }
  547.  
  548. move_latexlinepoint(x, y)
  549. int    x, y;
  550. {
  551.     CURSOR     c;
  552.  
  553.     draw_pointlink(INV_PAINT);
  554.     latex_endpoint(latex_fix_x, latex_fix_y, x, y, &cur_x, &cur_y,
  555.         latexarrow_mode, (magnet_mode)? 5: 1);
  556.     draw_pointlink(INV_PAINT);
  557.     c = (x == cur_x  &&  y == cur_y)? &null_cursor: &crosshair_cursor;
  558.     if (c != cur_latexcursor) {
  559.         set_temp_cursor(c);
  560.         cur_latexcursor = c;
  561.         }
  562.     }
  563.  
  564. fix_box(x, y)
  565. int    x, y;
  566. {
  567.     draw_rectbox(fix_x, fix_y, cur_x, cur_y, INV_PAINT);
  568.     new_position.x = x;
  569.     new_position.y = y;
  570.     clean_up();
  571.     set_action_object(F_MOVE_POINT, O_POLYLINE);
  572.     set_latestline(line);
  573.     relocate_linepoint(line, x, y, fix_x, fix_y, moved_point, 
  574.         left_point);
  575.     wrapup_movepoint();
  576.     }
  577.  
  578. assign_newboxpoint(b, x1, y1, x2, y2)
  579. F_line    *b;
  580. int    x1, y1, x2, y2;
  581. {
  582.     F_point    *p;
  583.     register int tmp;
  584.  
  585.     p = b->points;
  586.     if (x1 > x2)        /* sort them so that lower left is first */
  587.         {
  588.         tmp = x1; x1 = x2; x2 = tmp;
  589.         }
  590.     if (y1 > y2)
  591.         {
  592.         tmp = y1; y1 = y2; y2 = tmp;
  593.         }
  594.     p->x = x1;    p->y = y1;    p = p->next;
  595.     p->x = x1;    p->y = y2;    p = p->next;
  596.     p->x = x2;    p->y = y2;    p = p->next;
  597.     p->x = x2;    p->y = y1;    p = p->next;
  598.     p->x = x1;    p->y = y1;    p = p->next;
  599.     }
  600.  
  601. fix_movedlinepoint(x, y)
  602. int    x, y;
  603. {
  604.     draw_pointlink(INV_PAINT);
  605.     new_position.x = x;
  606.     new_position.y = y;
  607.     clean_up();
  608.     set_action_object(F_MOVE_POINT, O_POLYLINE);
  609.     set_latestline(cur_l);
  610.     relocate_linepoint(cur_l, x, y, fix_x, fix_y, moved_point, left_point);
  611.     wrapup_movepoint();
  612.     }
  613.  
  614. fix_movedlatexlinepoint(x, y)
  615. int    x, y;
  616. {
  617.     draw_pointlink(INV_PAINT);
  618.     latex_endpoint(latex_fix_x, latex_fix_y, x, y, &x, &y,
  619.         latexarrow_mode, (magnet_mode)? 5: 1);
  620.     if (cur_latexcursor != &crosshair_cursor)
  621.         set_temp_cursor(&crosshair_cursor);
  622.     win_setmouseposition(canvas_win, x, y);
  623.     new_position.x = x;
  624.     new_position.y = y;
  625.     clean_up();
  626.     set_action_object(F_MOVE_POINT, O_POLYLINE);
  627.     set_latestline(cur_l);
  628.     relocate_linepoint(cur_l, x, y, fix_x, fix_y, moved_point, left_point);
  629.     wrapup_movepoint();
  630.     }
  631.  
  632. relocate_linepoint(line, x, y, fix_x, fix_y, moved_point, left_point)
  633. F_line    *line;
  634. int    x, y;
  635. F_point    *moved_point, *left_point;
  636. {
  637.     if (pointmarker_shown) toggle_linepointmarker(line);
  638.     draw_line(line, ERASE);
  639.     switch (line->type) {
  640.         case T_BOX :
  641.         case T_ARC_BOX:
  642.         assign_newboxpoint(line, fix_x, fix_y, x, y);
  643.         break;
  644.         case T_POLYGON :
  645.         if (line->points == moved_point) {
  646.             left_point->next->x = x;
  647.             left_point->next->y = y;
  648.             }
  649.         default :
  650.         moved_point->x = x;
  651.         moved_point->y = y;
  652.         }
  653.     draw_line(line, PAINT);
  654.     if (pointmarker_shown) toggle_linepointmarker(line);  
  655.     set_modifiedflag();
  656.     }
  657.  
  658. draw_pointlink(op)
  659. int    op;
  660. {
  661.     F_point    *p;
  662.  
  663.     if (left_point != NULL) {
  664.         pw_vector(canvas_win, left_point->x, left_point->y,
  665.             cur_x, cur_y, op, 1, SOLID_LINE, 0.0);
  666.         }
  667.     if ((p = moved_point->next) != NULL) {
  668.         pw_vector(canvas_win, p->x, p->y, cur_x, cur_y, op, 1, SOLID_LINE, 0.0);
  669.         }
  670.     }
  671.  
  672. F_line *
  673. line_point_search(x, y, tol, p, q)
  674. int    x, y, tol;
  675. F_point    **p, **q;
  676. {
  677.     F_line    *l;
  678.     F_point    *a, *b;
  679.  
  680.     for (l = objects.lines; l != NULL; l= l->next) {
  681.         for (a = NULL, b = l->points; b != NULL; a = b, b = b->next) {
  682.         if (abs(b->x - x) <= tol && abs(b->y - y) <= tol) {
  683.             *p = a;
  684.             *q = b;
  685.             return(l);
  686.             }
  687.         }
  688.         }
  689.     return(NULL);
  690.     }
  691.