home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume19 / xfig / part08 / e_arrow.c next >
Encoding:
C/C++ Source or Header  |  1993-05-27  |  9.2 KB  |  333 lines
  1. /*
  2.  * FIG : Facility for Interactive Generation of figures
  3.  * Copyright (c) 1985 by Supoj Sutanthavibul
  4.  *
  5.  * "Permission to use, copy, modify, distribute, and sell this software and its
  6.  * documentation for any purpose is hereby granted without fee, provided that
  7.  * the above copyright notice appear in all copies and that both the copyright
  8.  * notice and this permission notice appear in supporting documentation. 
  9.  * No representations are made about the suitability of this software for 
  10.  * any purpose.  It is provided "as is" without express or implied warranty."
  11.  */
  12.  
  13. #include "fig.h"
  14. #include "resources.h"
  15. #include "mode.h"
  16. #include "object.h"
  17. #include "paintop.h"
  18. #include "u_create.h"
  19. #include "u_search.h"
  20. #include "w_canvas.h"
  21. #include "w_mousefun.h"
  22.  
  23. static        add_arrow_head();
  24. static        delete_arrow_head();
  25.  
  26. arrow_head_selected()
  27. {
  28.     set_mousefun("add arrow", "delete arrow", "");
  29.     canvas_kbd_proc = null_proc;
  30.     canvas_locmove_proc = null_proc;
  31.     init_searchproc_left(add_arrow_head);
  32.     init_searchproc_middle(delete_arrow_head);
  33.     canvas_leftbut_proc = point_search_left;
  34.     canvas_middlebut_proc = point_search_middle;
  35.     canvas_rightbut_proc = null_proc;
  36.     set_cursor(pick9_cursor);
  37. }
  38.  
  39. static
  40. add_arrow_head(obj, type, x, y, p, q)
  41.     char       *obj;
  42.     int            type, x, y;
  43.     F_point       *p, *q;
  44. {
  45.     switch (type) {
  46.     case O_POLYLINE:
  47.     cur_l = (F_line *) obj;
  48.     add_linearrow(cur_l, p, q);
  49.     break;
  50.     case O_SPLINE:
  51.     cur_s = (F_spline *) obj;
  52.     add_splinearrow(cur_s, p, q);
  53.     break;
  54.     case O_ARC:
  55.     cur_a = (F_arc *) obj;
  56.     /* dirty trick - arc point number is stored in p */
  57.     add_arcarrow(cur_a, (int) p);
  58.     break;
  59.     }
  60. }
  61.  
  62. static
  63. delete_arrow_head(obj, type, x, y, p, q)
  64.     char       *obj;
  65.     int            type, x, y;
  66.     F_point       *p, *q;
  67. {
  68.     switch (type) {
  69.     case O_POLYLINE:
  70.     cur_l = (F_line *) obj;
  71.     delete_linearrow(cur_l, p, q);
  72.     break;
  73.     case O_SPLINE:
  74.     cur_s = (F_spline *) obj;
  75.     delete_splinearrow(cur_s, p, q);
  76.     break;
  77.     case O_ARC:
  78.     cur_a = (F_arc *) obj;
  79.     /* dirty trick - arc point number is stored in p */
  80.     delete_arcarrow(cur_a, (int) p);
  81.     break;
  82.     }
  83. }
  84.  
  85. add_linearrow(line, prev_point, selected_point)
  86.     F_line       *line;
  87.     F_point       *prev_point, *selected_point;
  88. {
  89.     if (line->points->next == NULL)
  90.     return;            /* A single point line */
  91.  
  92.     if (prev_point == NULL) {    /* selected_point is the first point */
  93.     if (line->back_arrow)
  94.         return;
  95.     line->back_arrow = backward_arrow();
  96.     mask_toggle_linemarker(line);
  97.     draw_arrow(selected_point->next->x, selected_point->next->y,
  98.            selected_point->x, selected_point->y, line->back_arrow,
  99.            PAINT, line->color);
  100.     mask_toggle_linemarker(line);
  101.     } else if (selected_point->next == NULL) {    /* forward arrow */
  102.     if (line->for_arrow)
  103.         return;
  104.     line->for_arrow = forward_arrow();
  105.     mask_toggle_linemarker(line);
  106.     draw_arrow(prev_point->x, prev_point->y, selected_point->x,
  107.            selected_point->y, line->for_arrow, PAINT, line->color);
  108.     mask_toggle_linemarker(line);
  109.     } else
  110.     return;
  111.     clean_up();
  112.     set_last_prevpoint(prev_point);
  113.     set_last_selectedpoint(selected_point);
  114.     set_latestline(line);
  115.     set_action_object(F_ADD_ARROW_HEAD, O_POLYLINE);
  116.     set_modifiedflag();
  117. }
  118.  
  119. add_arcarrow(arc, point_num)
  120.     F_arc       *arc;
  121.     int            point_num;
  122. {
  123.  
  124.     if (point_num == 0) {    /* backward arrow  */
  125.     if (arc->back_arrow)
  126.         return;
  127.     arc->back_arrow = backward_arrow();
  128.     mask_toggle_arcmarker(arc);
  129.     draw_arcarrows(arc, PAINT);
  130.     mask_toggle_arcmarker(arc);
  131.     } else if (point_num == 2) {/* for_arrow  */
  132.     if (arc->for_arrow)
  133.         return;
  134.     arc->for_arrow = forward_arrow();
  135.     mask_toggle_arcmarker(arc);
  136.     draw_arcarrows(arc, PAINT);
  137.     mask_toggle_arcmarker(arc);
  138.     } else
  139.     return;
  140.     clean_up();
  141.     set_last_arcpointnum(point_num);
  142.     set_latestarc(arc);
  143.     set_action_object(F_ADD_ARROW_HEAD, O_ARC);
  144.     set_modifiedflag();
  145. }
  146.  
  147. add_splinearrow(spline, prev_point, selected_point)
  148.     F_spline       *spline;
  149.     F_point       *prev_point, *selected_point;
  150. {
  151.     F_point       *p;
  152.     F_control       *c;
  153.  
  154.     if (prev_point == NULL) {    /* add backward arrow */
  155.     if (spline->back_arrow)
  156.         return;
  157.     p = selected_point->next;
  158.     spline->back_arrow = backward_arrow();
  159.     mask_toggle_splinemarker(spline);
  160.     if (normal_spline(spline)) {
  161.         draw_arrow(p->x, p->y, selected_point->x,
  162.                selected_point->y, spline->back_arrow, PAINT,
  163.                spline->color);
  164.     } else {
  165.         c = spline->controls;
  166.         draw_arrow(round(c->rx), round(c->ry), selected_point->x,
  167.                selected_point->y, spline->back_arrow, PAINT,
  168.                spline->color);
  169.     }
  170.     mask_toggle_splinemarker(spline);
  171.     } else if (selected_point->next == NULL) {    /* add forward arrow */
  172.     if (spline->for_arrow)
  173.         return;
  174.     spline->for_arrow = forward_arrow();
  175.     mask_toggle_splinemarker(spline);
  176.     if (normal_spline(spline)) {
  177.         draw_arrow(prev_point->x, prev_point->y,
  178.                selected_point->x, selected_point->y,
  179.                spline->for_arrow, PAINT,
  180.                spline->color);
  181.     } else {
  182.         for (c = spline->controls; c->next != NULL; c = c->next);
  183.         draw_arrow(round(c->lx), round(c->ly), selected_point->x,
  184.                selected_point->y, spline->for_arrow, PAINT,
  185.                spline->color);
  186.     }
  187.     mask_toggle_splinemarker(spline);
  188.     }
  189.     clean_up();
  190.     set_last_prevpoint(prev_point);
  191.     set_last_selectedpoint(selected_point);
  192.     set_latestspline(spline);
  193.     set_action_object(F_ADD_ARROW_HEAD, O_SPLINE);
  194.     set_modifiedflag();
  195. }
  196.  
  197. delete_linearrow(line, prev_point, selected_point)
  198.     F_line       *line;
  199.     F_point       *prev_point, *selected_point;
  200. {
  201.     if (line->points->next == NULL)
  202.     return;            /* A single point line */
  203.  
  204.     if (prev_point == NULL) {    /* selected_point is the first point */
  205.     if (!line->back_arrow)
  206.         return;
  207.     mask_toggle_linemarker(line);
  208.     draw_arrow(selected_point->next->x, selected_point->next->y,
  209.           selected_point->x, selected_point->y, line->back_arrow, ERASE,
  210.            line->color);
  211.     free((char *) line->back_arrow);
  212.     line->back_arrow = NULL;
  213.     draw_line(line, PAINT);
  214.     mask_toggle_linemarker(line);
  215.     } else if (selected_point->next == NULL) {    /* forward arrow */
  216.     if (!line->for_arrow)
  217.         return;
  218.     mask_toggle_linemarker(line);
  219.     draw_arrow(prev_point->x, prev_point->y, selected_point->x,
  220.            selected_point->y, line->for_arrow, ERASE,
  221.            line->color);
  222.     free((char *) line->for_arrow);
  223.     line->for_arrow = NULL;
  224.     draw_line(line, PAINT);
  225.     mask_toggle_linemarker(line);
  226.     } else
  227.     return;
  228.     clean_up();
  229.     set_last_prevpoint(prev_point);
  230.     set_last_selectedpoint(selected_point);
  231.     set_latestline(line);
  232.     set_action_object(F_DELETE_ARROW_HEAD, O_POLYLINE);
  233.     set_modifiedflag();
  234. }
  235.  
  236. delete_arcarrow(arc, point_num)
  237.     F_arc       *arc;
  238.     int            point_num;
  239. {
  240.     if (point_num == 0) {    /* backward arrow  */
  241.     if (!arc->back_arrow)
  242.         return;
  243.     mask_toggle_arcmarker(arc);
  244.     draw_arcarrows(arc, ERASE);
  245.     free((char *) arc->back_arrow);
  246.     arc->back_arrow = NULL;
  247.     draw_arc(arc, PAINT);
  248.     mask_toggle_arcmarker(arc);
  249.     } else if (point_num == 2) {/* for_arrow  */
  250.     if (!arc->for_arrow)
  251.         return;
  252.     mask_toggle_arcmarker(arc);
  253.     draw_arcarrows(arc, ERASE);
  254.     free((char *) arc->for_arrow);
  255.     arc->for_arrow = NULL;
  256.     draw_arc(arc, PAINT);
  257.     mask_toggle_arcmarker(arc);
  258.     } else
  259.     return;
  260.     clean_up();
  261.     set_last_arcpointnum(point_num);
  262.     set_latestarc(arc);
  263.     set_action_object(F_DELETE_ARROW_HEAD, O_ARC);
  264.     set_modifiedflag();
  265. }
  266.  
  267. delete_splinearrow(spline, prev_point, selected_point)
  268.     F_spline       *spline;
  269.     F_point       *prev_point, *selected_point;
  270. {
  271.     F_point       *p;
  272.  
  273.     if (closed_spline(spline))
  274.     return;
  275.     if (prev_point == NULL) {    /* selected_point is the first point */
  276.     if (!spline->back_arrow)
  277.         return;
  278.     mask_toggle_splinemarker(spline);
  279.     p = selected_point->next;
  280.     if (normal_spline(spline)) {
  281.         draw_arrow(p->x, p->y, selected_point->x,
  282.                selected_point->y, spline->back_arrow, ERASE,
  283.                spline->color);
  284.         free((char *) spline->back_arrow);
  285.         spline->back_arrow = NULL;
  286.         draw_spline(spline, PAINT);
  287.     } else {
  288.         F_control       *a;
  289.  
  290.         a = spline->controls;
  291.         draw_arrow(round(a->rx), round(a->ry), selected_point->x,
  292.                selected_point->y, spline->back_arrow, ERASE,
  293.                spline->color);
  294.         free((char *) spline->back_arrow);
  295.         spline->back_arrow = NULL;
  296.         draw_spline(spline, PAINT);
  297.     }
  298.     mask_toggle_splinemarker(spline);
  299.     } else if (selected_point->next == NULL) {    /* forward arrow */
  300.     if (!spline->for_arrow)
  301.         return;
  302.     mask_toggle_splinemarker(spline);
  303.     if (normal_spline(spline)) {
  304.         draw_arrow(prev_point->x, prev_point->y,
  305.                selected_point->x, selected_point->y,
  306.                spline->for_arrow, ERASE,
  307.                spline->color);
  308.         free((char *) spline->for_arrow);
  309.         spline->for_arrow = NULL;
  310.         draw_spline(spline, PAINT);
  311.     } else {
  312.         F_control       *a, *b;
  313.  
  314.         a = spline->controls;
  315.         for (b = a->next; b->next != NULL; a = b, b = b->next);
  316.         draw_arrow(round(b->lx), round(b->ly), selected_point->x,
  317.                selected_point->y, spline->for_arrow, ERASE,
  318.                spline->color);
  319.         free((char *) spline->for_arrow);
  320.         spline->for_arrow = NULL;
  321.         draw_spline(spline, PAINT);
  322.     }
  323.     mask_toggle_splinemarker(spline);
  324.     } else
  325.     return;
  326.     clean_up();
  327.     set_last_prevpoint(prev_point);
  328.     set_last_selectedpoint(selected_point);
  329.     set_latestspline(spline);
  330.     set_action_object(F_DELETE_ARROW_HEAD, O_SPLINE);
  331.     set_modifiedflag();
  332. }
  333.