home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume17 / xtexcad1 / part07 < prev    next >
Encoding:
Text File  |  1992-04-20  |  50.2 KB  |  2,181 lines
  1. Newsgroups: comp.sources.x
  2. Path: uunet!zaphod.mps.ohio-state.edu!mips!msi!dcmartin
  3. From: Fritz Haubensak <hsk@informatik.uni-wuerzburg.de>
  4. Subject: v17i071: TeXcad (X) version 1.2, Part07/10
  5. Message-ID: <1992Apr21.131401.2475@msi.com>
  6. Originator: dcmartin@fascet
  7. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  8. Nntp-Posting-Host: fascet
  9. Organization: Molecular Simulations, Inc.
  10. References: <csx-17i065-xtexcad-1.2@uunet.UU.NET>
  11. Date: Tue, 21 Apr 1992 13:14:01 GMT
  12. Approved: dcmartin@msi.com
  13. Lines: 2166
  14.  
  15. Submitted-by: Fritz Haubensak <hsk@informatik.uni-wuerzburg.de>
  16. Posting-number: Volume 17, Issue 71
  17. Archive-name: xtexcad-1.2/part07
  18.  
  19. # this is part.07 (part 7 of a multipart archive)
  20. # do not concatenate these parts, unpack them in order with /bin/sh
  21. # file oberfl.c continued
  22. #
  23. if test ! -r _shar_seq_.tmp; then
  24.     echo 'Please unpack part 1 first!'
  25.     exit 1
  26. fi
  27. (read Scheck
  28.  if test "$Scheck" != 7; then
  29.     echo Please unpack part "$Scheck" next!
  30.     exit 1
  31.  else
  32.     exit 0
  33.  fi
  34. ) < _shar_seq_.tmp || exit 1
  35. if test ! -f _shar_wnt_.tmp; then
  36.     echo 'x - still skipping oberfl.c'
  37. else
  38. echo 'x - continuing file oberfl.c'
  39. sed 's/^X//' << 'SHAR_EOF' >> 'oberfl.c' &&
  40. X    XtSetArg(args[n], XtNwidth, 140);
  41. X    n++;
  42. X    XtSetArg(args[n], XtNjustify, XtJustifyCenter);
  43. X    n++;
  44. X    XtSetArg(args[n], XtNshapeStyle, XmuShapeOval);
  45. X    n++;
  46. X    XtSetArg(args[n], XtNstate, False);
  47. X    n++;
  48. X    
  49. X    din = XtCreateManagedWidget("page", toggleWidgetClass, dummy1, args, n);
  50. X    XtAddCallback(din, XtNcallback, full_dina4, NULL);
  51. X
  52. X    n = 0;
  53. X
  54. X    XtSetArg(args[n], XtNlabel, "enable ruler");
  55. X    n++;
  56. X    XtSetArg(args[n], XtNheight, 30);
  57. X    n++;
  58. X    XtSetArg(args[n], XtNwidth, 140);
  59. X    n++;
  60. X    XtSetArg(args[n], XtNjustify, XtJustifyCenter);
  61. X    n++;
  62. X    XtSetArg(args[n], XtNshapeStyle, XmuShapeOval);
  63. X    n++;
  64. X    XtSetArg(args[n], XtNstate, True);
  65. X    n++;
  66. X    
  67. X    rul = XtCreateManagedWidget("lineal", toggleWidgetClass, dummy1, args, n);
  68. X    XtAddCallback(rul, XtNcallback, ruler_switch, NULL);
  69. X
  70. X    n = 0;
  71. X
  72. X    XtSetArg(args[n], XtNlabel, "cross wire");
  73. X    n++;
  74. X    XtSetArg(args[n], XtNheight, 30);
  75. X    n++;
  76. X    XtSetArg(args[n], XtNwidth, 140);
  77. X    n++;
  78. X    XtSetArg(args[n], XtNjustify, XtJustifyCenter);
  79. X    n++;
  80. X    XtSetArg(args[n], XtNshapeStyle, XmuShapeOval);
  81. X    n++;
  82. X    XtSetArg(args[n], XtNstate, False);
  83. X    n++;
  84. X    
  85. X    cross_curs = XtCreateManagedWidget("cross", toggleWidgetClass, dummy1, args, n);
  86. X    XtAddCallback(cross_curs, XtNcallback, cross_switch, NULL);
  87. X
  88. X    n = 0;
  89. X
  90. X    XtSetArg(args[n], XtNlabel, "watch line length");
  91. X    n++;
  92. X    XtSetArg(args[n], XtNheight, 30);
  93. X    n++;
  94. X    XtSetArg(args[n], XtNwidth, 140);
  95. X    n++;
  96. X    XtSetArg(args[n], XtNjustify, XtJustifyCenter);
  97. X    n++;
  98. X    XtSetArg(args[n], XtNshapeStyle, XmuShapeOval);
  99. X    n++;
  100. X    XtSetArg(args[n], XtNstate, False);
  101. X    n++;
  102. X    
  103. X    length_line = XtCreateManagedWidget("llline", toggleWidgetClass, dummy1, args, n);
  104. X    XtAddCallback(length_line, XtNcallback, l_length_switch, NULL);
  105. X    line_length = 0;
  106. X
  107. X    /* add action to translation manager */
  108. X    XtAddActions(actions, XtNumber(actions));
  109. X    XtOverrideTranslations(radio_up, trans_table1);
  110. X    XtOverrideTranslations(raster1, trans_table2);
  111. X    XtOverrideTranslations(snap1, trans_table2);
  112. X    XtOverrideTranslations(slp, trans_table2);
  113. X    XtOverrideTranslations(dias, trans_table2);
  114. X    XtOverrideTranslations(read_number, trans_table);
  115. X
  116. }
  117. /*-----------------------------------------------------------*/
  118. X
  119. void
  120. print_msg(Widget text_widget, char *msg)
  121. {
  122. X    /* prints messages into the welcome and report widget */
  123. X
  124. X    XawTextPosition text_pos;
  125. X    int             result;
  126. X    XawTextBlock    text_block;
  127. X
  128. X
  129. X    /* get current position of Cursor */
  130. X    text_pos = XawTextGetInsertionPoint(text_widget);
  131. X
  132. X
  133. X    /* text_block init. */
  134. X    text_block.firstPos = 0;
  135. X    text_block.length = strlen(msg);
  136. X    text_block.ptr = msg;
  137. X    text_block.format = FMT8BIT;
  138. X
  139. X    XawTextReplace(text_widget, text_pos, text_pos, &text_block);
  140. X
  141. X    /* display text */
  142. X    XawTextDisplay(text_widget);
  143. }
  144. SHAR_EOF
  145. echo 'File oberfl.c is complete' &&
  146. chmod 0644 oberfl.c ||
  147. echo 'restore of oberfl.c failed'
  148. Wc_c="`wc -c < 'oberfl.c'`"
  149. test 37008 -eq "$Wc_c" ||
  150.     echo 'oberfl.c: original size 37008, current size' "$Wc_c"
  151. rm -f _shar_wnt_.tmp
  152. fi
  153. # ============= oberfl.h ==============
  154. if test -f 'oberfl.h' -a X"$1" != X"-c"; then
  155.     echo 'x - skipping oberfl.h (File already exists)'
  156.     rm -f _shar_wnt_.tmp
  157. else
  158. > _shar_wnt_.tmp
  159. echo 'x - extracting oberfl.h (Text)'
  160. sed 's/^X//' << 'SHAR_EOF' > 'oberfl.h' &&
  161. /* xtexcad  V1.2 - graphic editor for LaTeX */
  162. /* 1991 by K.Zitzmann */
  163. /* header-file oberfl.h */
  164. X
  165. X
  166. #ifndef OBERFLH
  167. #define OBERFLH
  168. X
  169. X
  170. X
  171. /* prototypes */
  172. X
  173. X
  174. void popup_init(void);
  175. void paintboard(void);
  176. void textup_init(void);
  177. void print_msg(Widget w, char *msg); /* display message in textwidget */
  178. void radio_init(void);
  179. void command_init(void);
  180. void headline(Widget w, char *txt);
  181. X
  182. X
  183. X
  184. /* constant */
  185. X
  186. X extern const Dimension cmd_btn_width;
  187. X extern const Dimension cmd_btn_height;
  188. X extern const vertical_distance,new_section;
  189. X
  190. X extern const yorigin;
  191. X
  192. X #define xorigin (cmd_btn_width+2*new_section)
  193. X 
  194. X extern const y_A4_max;
  195. X extern const y_A4_min;
  196. X extern const x_A4_max;
  197. X extern const x_A4_min;
  198. X
  199. X 
  200. /* global variables */ 
  201. X
  202. X extern Widget toplevel,canvas,pboard,textup,wtext,input_up,get_up,box_me_up;
  203. X extern Widget line_cmd,box_cmd,circle_cmd,text_cmd,file_cmd;
  204. X extern Widget vector_cmd,zoom_cmd,refresh_cmd,erase_cmd,edit_cmd,options_cmd;
  205. X extern Widget snap1,raster1,radio_up,slp,dias;
  206. X extern Widget txt2,txt3,raster_up,ask_up,sign_up,sign_msg;
  207. X extern Widget coordinates,about,pop_adjust_up,adj_txt2,fileselector,bezier_cmd;
  208. X extern Widget lft,rgt,up,dwn,zentr;
  209. X
  210. X extern Arg args[10]; 
  211. X extern int n,m;
  212. X
  213. X extern Boolean snap, raster; /* radio-button-options */
  214. X extern Boolean zoomed,steigung,durchmesser,refr_auto,dina4;
  215. X extern Boolean ruler,cross;
  216. X
  217. X extern char graph_action,shadow; /* current action : 'L'=line etc. */
  218. X
  219. X extern char filename[100];
  220. X extern char chain[100];
  221. X extern char titlename[200];
  222. X extern char boxinput[256];
  223. X extern char textinput[256];
  224. X 
  225. X 
  226. X extern char txtpos[3];
  227. X extern float xur,yur;
  228. X extern GC gc,copy_gc; /* Graphic Context ID */
  229. X
  230. X extern Pixmap about_map;
  231. X 
  232. X 
  233. X 
  234. X /* Figure Data Base */
  235. X 
  236. X extern struct fig1 {
  237. X    float x,y,h,v;
  238. X    struct fig1 *next;
  239. X    } oval;
  240. X
  241. X extern struct fig2 {
  242. X    float x,y,h,v;
  243. X    struct fig2 *next;
  244. X    int radius;
  245. X    } filledBox,strich,pfeil,disc,kreis;
  246. X
  247. X extern struct fig3 {
  248. X    float x,y,h,v;
  249. X    char *text;
  250. X    char textpos[2];
  251. X    struct fig3 *next;
  252. X    } framedBox;
  253. X
  254. X extern struct fig4 {
  255. X    float x,y,h,v;
  256. X    char *text;
  257. X    char textpos[2];
  258. X    float dashlength;
  259. X    struct fig4 *next;
  260. X    } dashedBox;
  261. X
  262. X extern struct fig5 {
  263. X    float x,y;
  264. X    char *text;
  265. X    char textpos[2]; /* for the makebox-command */
  266. X    struct fig5 *next;
  267. X    } message;
  268. X
  269. X extern struct fig6 {
  270. X     float ax,ay; /* startpoint */
  271. X     float ex,ey; /* endpoint */
  272. X     float sx,sy; /* controlpoint */
  273. X    struct fig6 *next;
  274. X     } bezier;
  275. X
  276. X /* box,oval: first coordinates must be the upper left corner */
  277. X /* circle: x,y determine the middlepoint, h,v are useless after creating object */
  278. X
  279. X extern struct fig2 *disc_start, *disc_curr, *disc_marker;
  280. X extern struct fig2 *kreis_start, *kreis_curr, *kreis_marker;
  281. X extern struct fig2 *filledBox_start, *filledBox_curr, *filledBox_marker;
  282. X extern struct fig1 *oval_start, *oval_curr, *oval_marker;
  283. X extern struct fig2 *strich_start, *strich_curr, *strich_marker;
  284. X extern struct fig2 *pfeil_start, *pfeil_curr, *pfeil_marker;
  285. X extern struct fig3 *framedBox_start, *framedBox_curr, *framedBox_marker;
  286. X extern struct fig4 *dashedBox_start, *dashedBox_curr, *dashedBox_marker;
  287. X extern struct fig5 *message_start, *message_curr, *message_marker;
  288. X extern struct fig6 *bezier_start, *bezier_curr, *bezier_marker;
  289. X
  290. X
  291. X extern int x_zoom_max;
  292. X extern int x_zoom_min;
  293. X extern int y_zoom_max;
  294. X extern int y_zoom_min;
  295. X
  296. X extern int xmotion;
  297. X extern int ymotion;
  298. X
  299. X /* user data */
  300. extern char    aa;
  301. extern char    bb;
  302. extern char    cc;
  303. extern char    dd;
  304. extern char    ee;
  305. extern char    ff;
  306. extern char    gg;
  307. extern char    hh;
  308. extern char    ii;
  309. extern char    jj;
  310. extern char    kk;
  311. extern char    ll;
  312. extern char    mm;
  313. extern char    nn;
  314. extern char    oo;
  315. extern char    pp;
  316. extern char    qq;
  317. extern char    rr;
  318. extern char    ss;
  319. extern char    tt;
  320. extern char    uu;
  321. extern char    vv;
  322. extern char    ww;
  323. extern char    xx;
  324. extern char    yy;
  325. extern char    zz;
  326. extern char     point;
  327. extern char     DUMMY;
  328. extern char    minus;
  329. extern char    ka;
  330. extern char    kb;
  331. extern char    kc;
  332. extern char    kd;
  333. extern char    ke;
  334. extern char    kf;
  335. extern char    kg;
  336. extern char    kh;
  337. extern char    ki;
  338. extern char    kj;
  339. extern char    klein_k;
  340. extern char    kl;
  341. extern char    km;
  342. extern char    kn;
  343. extern char    ko;
  344. extern char    kp;
  345. extern char    kq;
  346. extern char    kr;
  347. extern char    ks;
  348. extern char    kt;
  349. extern char    ku;
  350. extern char    kv;
  351. extern char    kw;
  352. extern char    kx;
  353. extern char    ky;
  354. extern char    kz;
  355. X
  356. #endif
  357. SHAR_EOF
  358. chmod 0644 oberfl.h ||
  359. echo 'restore of oberfl.h failed'
  360. Wc_c="`wc -c < 'oberfl.h'`"
  361. test 4292 -eq "$Wc_c" ||
  362.     echo 'oberfl.h: original size 4292, current size' "$Wc_c"
  363. rm -f _shar_wnt_.tmp
  364. fi
  365. # ============= patchlevel.h ==============
  366. if test -f 'patchlevel.h' -a X"$1" != X"-c"; then
  367.     echo 'x - skipping patchlevel.h (File already exists)'
  368.     rm -f _shar_wnt_.tmp
  369. else
  370. > _shar_wnt_.tmp
  371. echo 'x - extracting patchlevel.h (Text)'
  372. sed 's/^X//' << 'SHAR_EOF' > 'patchlevel.h' &&
  373. /* xtexcad  V1.2 - graphic editor for LaTeX */
  374. /* 1991 by K.Zitzmann */
  375. /* patchlevel.h */
  376. X
  377. #define PATCHLEVEL 0.0
  378. X
  379. SHAR_EOF
  380. chmod 0644 patchlevel.h ||
  381. echo 'restore of patchlevel.h failed'
  382. Wc_c="`wc -c < 'patchlevel.h'`"
  383. test 116 -eq "$Wc_c" ||
  384.     echo 'patchlevel.h: original size 116, current size' "$Wc_c"
  385. rm -f _shar_wnt_.tmp
  386. fi
  387. # ============= pickedit.c ==============
  388. if test -f 'pickedit.c' -a X"$1" != X"-c"; then
  389.     echo 'x - skipping pickedit.c (File already exists)'
  390.     rm -f _shar_wnt_.tmp
  391. else
  392. > _shar_wnt_.tmp
  393. echo 'x - extracting pickedit.c (Text)'
  394. sed 's/^X//' << 'SHAR_EOF' > 'pickedit.c' &&
  395. /* xtexcad  V1.1 - graphic editor for LaTeX */
  396. /* 1991 by K.Zitzmann */
  397. /* pickedit.c */
  398. X
  399. #include "x_stuff.h"
  400. #include "oberfl.h"
  401. #include "ereignis.h"
  402. #include "graphics.h"
  403. #include "pickedit.h"
  404. #include <math.h>
  405. X
  406. X
  407. X
  408. /* this data-structure contains the best matching objects which are */
  409. /* found during a pick-action... */
  410. X
  411. #define sumobj 5
  412. X
  413. int             maxobj = 5;
  414. X
  415. char            kind[sumobj];    /* the object type: 'L'=line, 'V'=vector,
  416. X                 * 'N'=framedBox etc */
  417. int             distance[sumobj];    /* the distance to the selected point
  418. X                     * on the screen */
  419. void           *obj[sumobj];    /* pointer to the current element in kind[] */
  420. int             tip;
  421. X
  422. int             x_pick, y_pick, currIndex;
  423. /* currIndex is THE index which points ALWAYS to the current object */
  424. X
  425. int             points = 10;    /* radius for edit circle */
  426. /* ----------------------------------- */
  427. /*
  428. X * interface to application is : set_pick_stack(x,y) and nextObject()  and
  429. X * currIndex
  430. X */
  431. X
  432. X
  433. void
  434. init_pick()
  435. {
  436. X    int             i;
  437. X    for (i = 0; i <= maxobj; i++)
  438. X    {
  439. X        kind[i] = '-';
  440. X        distance[i] = 9999;
  441. X        obj[i] = NULL;
  442. X    }
  443. X
  444. X    tip = 0;
  445. X    currIndex = 0;
  446. }
  447. X
  448. X
  449. int
  450. nextObject()
  451. {
  452. X    /* returns -1 if there is no object & otherwise the index */
  453. X    /* of the object in the global data-stucture */
  454. X
  455. X    if (kind[tip] == '-')
  456. X        return -1;    /* no object */
  457. X
  458. X    if (tip <= maxobj)
  459. X        tip++;
  460. X    else
  461. X        return -1;
  462. X
  463. X    currIndex = tip - 1;
  464. X
  465. X    return currIndex;
  466. }
  467. X
  468. X
  469. X
  470. void
  471. set_pick_stack(int x, int y)
  472. {
  473. X    /* fills the stack with matching objects */
  474. X    int             d, res;
  475. X    float           h, v;
  476. X    init_pick();
  477. X
  478. X    if (zoomed == True)
  479. X    {
  480. X        h = (float) x;
  481. X        v = (float) y;
  482. X        zoomed2real(&h, &v);
  483. X        x = h;
  484. X        y = v;
  485. X    }
  486. X    /* bezier */
  487. X    if (bezier_start != NULL)
  488. X    {    /* there is min. 1 entry */
  489. X        bezier_marker = bezier_start;
  490. X        res = analyse_bezier(bezier_marker, &d, x, y);
  491. X        if (res == 1)
  492. X            insert_object(bezier_marker, d, ii);
  493. X
  494. X        if (bezier_marker != bezier_curr)
  495. X        {
  496. X            do
  497. X            {
  498. X                bezier_marker = bezier_marker->next;
  499. X                res = analyse_bezier(bezier_marker, &d, x, y);
  500. X                if (res == 1)
  501. X                    insert_object(bezier_marker, d, ii);
  502. X            } while (bezier_marker != bezier_curr);
  503. X        }
  504. X    }
  505. X    /* line */
  506. X    if (strich_start != NULL)
  507. X    {    /* there is min. 1 entry */
  508. X        strich_marker = strich_start;
  509. X        res = analyse_pin(strich_marker, &d, x, y);
  510. X        if (res == 1)
  511. X            insert_object(strich_marker, d, ll);
  512. X
  513. X        if (strich_marker != strich_curr)
  514. X        {
  515. X            do
  516. X            {
  517. X                strich_marker = strich_marker->next;
  518. X                res = analyse_pin(strich_marker, &d, x, y);
  519. X                if (res == 1)
  520. X                    insert_object(strich_marker, d, ll);
  521. X            } while (strich_marker != strich_curr);
  522. X        }
  523. X    }
  524. X    /* vector */
  525. X    if (pfeil_start != NULL)
  526. X    {    /* there is min. 1 entry */
  527. X        pfeil_marker = pfeil_start;
  528. X        res = analyse_pin(pfeil_marker, &d, x, y);
  529. X        if (res == 1)
  530. X            insert_object(pfeil_marker, d, vv);
  531. X
  532. X        if (pfeil_marker != pfeil_curr)
  533. X        {
  534. X            do
  535. X            {
  536. X                pfeil_marker = pfeil_marker->next;
  537. X                res = analyse_pin(pfeil_marker, &d, x, y);
  538. X                if (res == 1)
  539. X                    insert_object(pfeil_marker, d, vv);
  540. X            } while (pfeil_marker != pfeil_curr);
  541. X        }
  542. X    }
  543. X    /* framedBox */
  544. X    if (framedBox_start != NULL)
  545. X    {    /* there is min. 1 entry */
  546. X        framedBox_marker = framedBox_start;
  547. X        res = analyse_nbox(framedBox_marker, &d, x, y);
  548. X        if (res == 1)
  549. X            insert_object(framedBox_marker, d, nn);
  550. X
  551. X        if (framedBox_marker != framedBox_curr)
  552. X        {
  553. X            do
  554. X            {
  555. X                framedBox_marker = framedBox_marker->next;
  556. X                res = analyse_nbox(framedBox_marker, &d, x, y);
  557. X                if (res == 1)
  558. X                    insert_object(framedBox_marker, d, nn);
  559. X            } while (framedBox_marker != framedBox_curr);
  560. X        }
  561. X    }
  562. X    /* dashedBox */
  563. X    if (dashedBox_start != NULL)
  564. X    {    /* there is min. 1 entry */
  565. X        dashedBox_marker = dashedBox_start;
  566. X        res = analyse_dbox(dashedBox_marker, &d, x, y);
  567. X        if (res == 1)
  568. X            insert_object(dashedBox_marker, d, dd);
  569. X
  570. X        if (dashedBox_marker != dashedBox_curr)
  571. X        {
  572. X            do
  573. X            {
  574. X                dashedBox_marker = dashedBox_marker->next;
  575. X                res = analyse_dbox(dashedBox_marker, &d, x, y);
  576. X                if (res == 1)
  577. X                    insert_object(dashedBox_marker, d, dd);
  578. X            } while (dashedBox_marker != dashedBox_curr);
  579. X        }
  580. X    }
  581. X    /* filledBox */
  582. X    if (filledBox_start != NULL)
  583. X    {    /* there is min. 1 entry */
  584. X        filledBox_marker = filledBox_start;
  585. X        res = analyse_fbox(filledBox_marker, &d, x, y);
  586. X        if (res == 1)
  587. X            insert_object(filledBox_marker, d, ff);
  588. X
  589. X
  590. X
  591. X        if (filledBox_marker != filledBox_curr)
  592. X        {
  593. X            do
  594. X            {
  595. X                filledBox_marker = filledBox_marker->next;
  596. X                res = analyse_fbox(filledBox_marker, &d, x, y);
  597. X                if (res == 1)
  598. X                    insert_object(filledBox_marker, d, ff);
  599. X            } while (filledBox_marker != filledBox_curr);
  600. X        }
  601. X    }
  602. X    /* normal circle */
  603. X    if (kreis_start != NULL)
  604. X    {    /* there is min. 1 entry */
  605. X        kreis_marker = kreis_start;
  606. X        res = analyse_ncircle(kreis_marker, &d, x, y);
  607. X        if (res == 1)
  608. X            insert_object(kreis_marker, d, cc);
  609. X
  610. X        if (kreis_marker != kreis_curr)
  611. X        {
  612. X            do
  613. X            {
  614. X                kreis_marker = kreis_marker->next;
  615. X                res = analyse_ncircle(kreis_marker, &d, x, y);
  616. X                if (res == 1)
  617. X                    insert_object(kreis_marker, d, cc);
  618. X            } while (kreis_marker != kreis_curr);
  619. X        }
  620. X    }
  621. X    /* filled circle */
  622. X    if (disc_start != NULL)
  623. X    {    /* there is min. 1 entry */
  624. X        disc_marker = disc_start;
  625. X        res = analyse_fcircle(disc_marker, &d, x, y);
  626. X        if (res == 1)
  627. X            insert_object(disc_marker, d, bb);
  628. X
  629. X        if (disc_marker != disc_curr)
  630. X        {
  631. X            do
  632. X            {
  633. X                disc_marker = disc_marker->next;
  634. X                res = analyse_fcircle(disc_marker, &d, x, y);
  635. X                if (res == 1)
  636. X                    insert_object(disc_marker, d, bb);
  637. X            } while (disc_marker != disc_curr);
  638. X        }
  639. X    }
  640. X    /* oval */
  641. X    if (oval_start != NULL)
  642. X    {    /* there is min. 1 entry */
  643. X        oval_marker = oval_start;
  644. X        res = analyse_ocircle(oval_marker, &d, x, y);
  645. X        if (res == 1)
  646. X            insert_object(oval_marker, d, oo);
  647. X
  648. X        if (oval_marker != oval_curr)
  649. X        {
  650. X            do
  651. X            {
  652. X                oval_marker = oval_marker->next;
  653. X                res = analyse_ocircle(oval_marker, &d, x, y);
  654. X                if (res == 1)
  655. X                    insert_object(oval_marker, d, oo);
  656. X            } while (oval_marker != oval_curr);
  657. X        }
  658. X    }
  659. }
  660. X
  661. X
  662. void
  663. insert_object(void *p, int d, char c)
  664. {
  665. X    int             i, k;
  666. X    /*
  667. X     * operations performed on global data-structure :
  668. X     * 
  669. X     * 
  670. X    /* compute insert-position
  671. X     */
  672. X    for (i = 0; (distance[i] < d) && (i != maxobj); i++);
  673. X
  674. X    if (i == maxobj)
  675. X        return;    /* the distance was too far; there are better objects */
  676. X
  677. X    /* move elements */
  678. X    for (k = (maxobj - 1); k > i; k--)
  679. X    {
  680. X        kind[k] = kind[k - 1];
  681. X        distance[k] = distance[k - 1];
  682. X        obj[k] = obj[k - 1];
  683. X    }
  684. X
  685. X    /* the new entry */
  686. X    kind[i] = c;
  687. X    distance[i] = d;
  688. X    obj[i] = p;
  689. X
  690. X    /* fin */
  691. X
  692. }
  693. X
  694. X
  695. /* function int analyse_xxxxxx() : */
  696. /* returns wether the object is a possible pick(1) or not(0) */
  697. /* p points to the object; d returns the distance to the object */
  698. /* xpos,ypos reference the pick position of the pointer */
  699. X
  700. X
  701. int analyse_bezier(struct fig6 *p, int *d, int xpos, int ypos)
  702. {
  703. X    int cmpdiff=9999;
  704. X    int diff;
  705. X    int x,y;
  706. X    float u;
  707. X    int zone=20;
  708. X    
  709. X    for (u=0; u<=1; u+=0.1)
  710. X    {
  711. X        x=(int)(p->ax*(1-u)*(1-u)+p->sx*(1-u)*2*u+p->ex*u*u);
  712. X            y=(int)(p->ay*(1-u)*(1-u)+p->sy*(1-u)*2*u+p->ey*u*u);
  713. X
  714. X        diff=calc_distance(x,y,xpos,ypos);
  715. X        
  716. X        cmpdiff=(cmpdiff<diff) ? cmpdiff : diff;
  717. X    }
  718. X
  719. X    (*d)= cmpdiff;
  720. X
  721. X    return (cmpdiff<zone) ? 1 : 0;
  722. }
  723. X
  724. X
  725. X
  726. X
  727. int
  728. analyse_pin(struct fig2 * p, int *d, int xpos, int ypos)
  729. {
  730. X    float           d1, d2;
  731. X    float           x1, x2, y1, y2;
  732. X    float           x, y, h, v;
  733. X    float           zone;
  734. X    double          alpha;
  735. X
  736. X
  737. X    /* 1. test : bounding rectangle */
  738. X
  739. X    x = p->x;
  740. X    y = p->y;
  741. X    v = p->v;
  742. X    h = p->h;
  743. X
  744. X    zone = 30.0;
  745. X
  746. X    norm_rectangle(&x, &y, &h, &v);
  747. X    /* now, x,y is the upper left corner of the rectangle */
  748. X
  749. X
  750. X
  751. X    x = x - zone;
  752. X    h = h + zone;
  753. X    y = y - zone;
  754. X    v = v + zone;
  755. X
  756. X
  757. X    if ((xpos < (int) x) || (xpos > (int) h) || (ypos < (int) y) || (ypos > (int) v))
  758. X        return 0;
  759. X
  760. X
  761. X
  762. X
  763. X    /* 2. test : distance */
  764. X
  765. X    x = (p->x);
  766. X    y = (p->y);
  767. X
  768. X    /* %%%%%%%%%%%%%%%%%%%%%  see documentation  %%%%%%%%%%%%%%%%%%%%% */
  769. X
  770. X    /* Vector 1 */
  771. X    x1 = (float) xpos - x;
  772. X    x2 = (float) ypos - y;
  773. X
  774. X    /* compute length of the above vector */
  775. X
  776. X    d1 = (float) sqrt((double) (x1 * x1 + x2 * x2));
  777. X    /* --- */
  778. X
  779. X    /* Vector 2 */
  780. X    y1 = (p->h) - x;
  781. X    y2 = (p->v) - y;
  782. X
  783. X    d2 = (float) sqrt((double) (y1 * y1 + y2 * y2));
  784. X    /* --- */
  785. X
  786. X
  787. X    alpha = (double) ((x1 * y1 + x2 * y2) / (d1 * d2));
  788. X
  789. X    /* acos(x),-1<=x<=1 */
  790. X    if (alpha < -1.0)
  791. X        alpha = -1.0;
  792. X    if (alpha > 1.0)
  793. X        alpha = 1.0;
  794. X
  795. X
  796. X    alpha = acos(alpha);
  797. X
  798. X
  799. X    (*d) = (int) (d1 * (float) sin(alpha));
  800. X
  801. X
  802. X    if ((*d) <= (int) zone)
  803. X        return 1;
  804. X    else
  805. X        return 0;
  806. X
  807. }
  808. X
  809. X
  810. X
  811. int
  812. analyse_nbox(struct fig3 * p, int *d, int xpos, int ypos)
  813. {
  814. X    /* normal box */
  815. X    float           zone;
  816. X    int             x, y, h, v;
  817. X    int             dt, db, dr, dl;
  818. X
  819. X
  820. X
  821. X    zone = 20.0;
  822. X
  823. X    x = (int) ((p->x) - zone);
  824. X    y = (int) ((p->y) - zone);
  825. X    v = (int) ((p->v) + zone);
  826. X    h = (int) ((p->h) + zone);
  827. X
  828. X    /* 1. test : bounding rectangle */
  829. X
  830. X    if ((xpos < x) || (xpos > h) || (ypos < y) || (ypos > v))
  831. X        return 0;
  832. X
  833. X
  834. X    /* 2. test : distance to a boundery */
  835. X
  836. X    dl = abs(xpos - (int) (p->x));
  837. X    dr = abs(xpos - (int) (p->h));
  838. X    dt = abs(ypos - (int) (p->y));
  839. X    db = abs(ypos - (int) (p->v));
  840. X
  841. X    /* compute the minimum of dr,dl,dt,db and store it in d */
  842. X
  843. X    if (dr < dl)
  844. X        dl = dr;    /* minimum in dl */
  845. X    if (db < dt)
  846. X        dt = db;    /* minimum in dt */
  847. X
  848. X    if (dt < dl)
  849. X        (*d) = dt;
  850. X    else
  851. X        (*d) = dl;
  852. X
  853. X
  854. X    if ((*d) <= (int) zone)
  855. X        return 1;
  856. X    else
  857. X        return 0;
  858. X
  859. }
  860. X
  861. X
  862. X
  863. int
  864. analyse_dbox(struct fig4 * p, int *d, int xpos, int ypos)
  865. {
  866. X    /* dashed box */
  867. X    float           zone;
  868. X    int             x, y, h, v;
  869. X    int             dt, db, dr, dl;
  870. X    zone = 20;
  871. X
  872. X    x = (int) ((p->x) - zone);
  873. X    y = (int) ((p->y) - zone);
  874. X    v = (int) ((p->v) + zone);
  875. X    h = (int) ((p->h) + zone);
  876. X
  877. X    /* 1. test : bounding rectangle */
  878. X
  879. X    if ((xpos < x) || (xpos > h) || (ypos < y) || (ypos > v))
  880. X        return 0;
  881. X
  882. X
  883. X    /* 2. test : distance to a boundery */
  884. X
  885. X    dl = abs(xpos - (int) (p->x));
  886. X    dr = abs(xpos - (int) (p->h));
  887. X    dt = abs(ypos - (int) (p->y));
  888. X    db = abs(ypos - (int) (p->v));
  889. X
  890. X    /* compute the minimum of dr,dl,dt,db and store it in d */
  891. X
  892. X    if (dr < dl)
  893. X        dl = dr;    /* minimum in dl */
  894. X    if (db < dt)
  895. X        dt = db;    /* minimum in dt */
  896. X
  897. X    if (dt < dl)
  898. X        (*d) = dt;
  899. X    else
  900. X        (*d) = dl;
  901. X
  902. X
  903. X    if ((*d) <= (int) zone)
  904. X        return 1;
  905. X    else
  906. X        return 0;
  907. X
  908. }
  909. X
  910. X
  911. X
  912. int
  913. analyse_fbox(struct fig2 * p, int *d, int xpos, int ypos)
  914. {
  915. X    /* filled box */
  916. X    int             x, y, h, v;
  917. X    x = (int) (p->x);
  918. X    y = (int) (p->y);
  919. X    v = (int) (p->v);
  920. X    h = (int) (p->h);
  921. X
  922. X    /* test : bounding rectangle */
  923. X
  924. X    if ((xpos < x) || (xpos > h) || (ypos < y) || (ypos > v))
  925. X        return 0;
  926. X
  927. X    (*d) = 0;    /* optimal pick */
  928. X
  929. X    return 1;
  930. X
  931. }
  932. X
  933. X
  934. int
  935. analyse_ncircle(struct fig2 * p, int *d, int xpos, int ypos)
  936. {
  937. X    /* normal circle */
  938. X    float           zone;
  939. X    int             x, y, h, v;
  940. X
  941. X
  942. X    zone = 20.0;
  943. X
  944. X    /* x,y is middlepoint/referencepoint */
  945. X    x = (int) ((p->x) - zone) - (p->radius);
  946. X    y = (int) ((p->y) - zone) - (p->radius);
  947. X    v = (int) ((p->y) + zone) + (p->radius);
  948. X    h = (int) ((p->x) + zone) + (p->radius);
  949. X
  950. X    /* now, x,y,h and v define the boundery-rectangle of the circle */
  951. X
  952. X    /* 1. test : bounding rectangle */
  953. X
  954. X    if ((xpos < x) || (xpos > h) || (ypos < y) || (ypos > v))
  955. X        return 0;
  956. X
  957. X
  958. X    /* 2. test : distance to a boundery (point on the circle-slice) */
  959. X    /*
  960. X     * compute the difference between radius and the length from
  961. X     * (xpos,ypos) to
  962. X     */
  963. X    /* the midlepoint */
  964. X
  965. X    x = xpos - (int) (p->x);
  966. X    y = ypos - (int) (p->y);
  967. X
  968. X    (*d) = abs((p->radius) -
  969. X           (int) sqrt((double) ((float) x * (float) x + (float) y * (float) y)));
  970. X
  971. X    if ((*d) <= (int) zone)
  972. X        return 1;
  973. X    else
  974. X        return 0;
  975. }
  976. X
  977. X
  978. X
  979. int
  980. analyse_ocircle(struct fig1 * p, int *d, int xpos, int ypos)
  981. {
  982. X    /* oval */
  983. X    int             zone;
  984. X    int             x, y, h, v;
  985. X    int             dt, db, dr, dl;
  986. X    zone = 20;
  987. X
  988. X    x = (int) (p->x) - zone;
  989. X    y = (int) (p->y) - zone;
  990. X    v = (int) (p->v) + zone;
  991. X    h = (int) (p->h) + zone;
  992. X
  993. X    /* 1. test : bounding rectangle */
  994. X
  995. X    if ((xpos < x) || (xpos > h) || (ypos < y) || (ypos > v))
  996. X        return 0;
  997. X
  998. X
  999. X    /* 2. test : distance to a boundery */
  1000. X
  1001. X    dl = abs(xpos - (int) (p->x));
  1002. X    dr = abs(xpos - (int) (p->h));
  1003. X    dt = abs(ypos - (int) (p->y));
  1004. X    db = abs(ypos - (int) (p->v));
  1005. X
  1006. X
  1007. X
  1008. X    /* compute the minimum of dr,dl,dt,db and store it in d */
  1009. X
  1010. X    if (dr < dl)
  1011. X        dl = dr;    /* minimum in dl */
  1012. X    if (db < dt)
  1013. X        dt = db;    /* minimum in dt */
  1014. X
  1015. X    if (dt < dl)
  1016. X        (*d) = dt;
  1017. X    else
  1018. X        (*d) = dl;
  1019. X
  1020. X
  1021. X    if ((*d) <= zone)
  1022. X        return 1;
  1023. X    else
  1024. X        return 0;
  1025. X
  1026. }
  1027. X
  1028. X
  1029. X
  1030. int
  1031. analyse_fcircle(struct fig2 * p, int *d, int xpos, int ypos)
  1032. {
  1033. X    /* filled circle */
  1034. X    int             x, y, h;
  1035. X
  1036. X
  1037. X
  1038. X
  1039. X    /*
  1040. X     * 1. test : the position of the selection point must be inside the
  1041. X     * fille circle
  1042. X     */
  1043. X    /*
  1044. X     * compute the difference between radius and the length from
  1045. X     * (xpos,ypos) to
  1046. X     */
  1047. X    /* the midlepoint */
  1048. X
  1049. X    x = (xpos - (int) (p->x));
  1050. X    y = (ypos - (int) (p->y));
  1051. X
  1052. X    h = (int) sqrt((double) ((float) x * (float) x + (float) y * (float) y));    /* length of this vector */
  1053. X
  1054. X    if (h < (p->radius))
  1055. X        (*d) = 0;    /* the selection point is fully inside the
  1056. X                 * circle */
  1057. X    else
  1058. X        return 0;
  1059. X
  1060. X    return 1;
  1061. }
  1062. X
  1063. X
  1064. X
  1065. void
  1066. set_pick_object(void)
  1067. {
  1068. X    /* Override Translation Manager */
  1069. X    XtTranslations  trans_table;
  1070. X    char            destination[80] = "<Btn1Up>: manage_pick()";
  1071. X    static XtActionsRec actions[80] = {{"manage_pick", manage_pick}};
  1072. X    XtAddActions(actions, XtNumber(actions));
  1073. X    trans_table = XtParseTranslationTable(destination);
  1074. X    XtOverrideTranslations(pboard, trans_table);
  1075. }
  1076. X
  1077. X
  1078. void
  1079. set_copy_object(void)
  1080. {
  1081. X    /* Override Translation Manager */
  1082. X    XtTranslations  trans_table;
  1083. X    char            destination[80] = "<Btn1Down>: manage_copy()";
  1084. X    static XtActionsRec actions[80] = {{"manage_copy", manage_copy}};
  1085. X    XtAddActions(actions, XtNumber(actions));
  1086. X    trans_table = XtParseTranslationTable(destination);
  1087. X    XtOverrideTranslations(pboard, trans_table);
  1088. }
  1089. X
  1090. X
  1091. X
  1092. void
  1093. leave_pick(char *message)
  1094. {
  1095. X    Position        xx, yy, y_rel, x_rel;
  1096. X    n = 0;
  1097. X    XtSetArg(args[n], XtNx, &x_rel);
  1098. X    n++;
  1099. X    XtSetArg(args[n], XtNy, &y_rel);
  1100. X    n++;
  1101. X    XtGetValues(pboard, args, n);
  1102. X    XtTranslateCoords(canvas, x_rel, y_rel, &xx, &yy);
  1103. X    n = 0;
  1104. X    XtSetArg(args[n], XtNx, 175 + xx);
  1105. X    n++;
  1106. X    XtSetArg(args[n], XtNy, 295 + yy);
  1107. X    n++;
  1108. X
  1109. X    XtSetValues(sign_up, args, n);
  1110. X
  1111. X    n = 0;
  1112. X    XtSetArg(args[n], XtNlabel, message);
  1113. X    n++;
  1114. X    XtSetValues(sign_msg, args, n);
  1115. X    XtPopupSpringLoaded(sign_up);
  1116. }
  1117. X
  1118. X
  1119. void
  1120. manage_pick(void)
  1121. {
  1122. X
  1123. X
  1124. X    int             index;
  1125. X    unsigned int    mask;
  1126. X
  1127. X
  1128. X
  1129. X
  1130. X    PointerPosition(&x_pick, &y_pick, &mask);
  1131. X
  1132. X    XtUninstallTranslations(pboard);
  1133. X
  1134. X    set_pick_stack(x_pick, y_pick);    /* pick_stack is filled with matching
  1135. X                     * objects */
  1136. X
  1137. X    index = nextObject();
  1138. X
  1139. X    if (index == -1)
  1140. X    {    /* no objects found */
  1141. X        left();
  1142. X        leave_pick("No valid object found !");
  1143. X        return;
  1144. X    } else
  1145. X        pick_manager();
  1146. }
  1147. X
  1148. X
  1149. X
  1150. X
  1151. X
  1152. void
  1153. pick_manager()
  1154. {
  1155. X    int             btn1 = 256, btn2 = 512, btn3 = 1024;
  1156. X    int             index;
  1157. X    int             x, y, h, v;
  1158. X    unsigned int    mask, mask2;
  1159. X    Display        *disp = XtDisplay(pboard);
  1160. X    Window          win = XtWindow(pboard);
  1161. X    headline(toplevel, "Actions: Button 1 to EDIT ---- Button 2 to MOVE ---- Button 3 for MORE");
  1162. X
  1163. X    while (True)
  1164. X    {
  1165. X
  1166. X        prepare_top_stack_object();
  1167. X
  1168. X        do
  1169. X        {    /* watch for any buttonPress */
  1170. X            PointerPosition(&x, &y, &mask);
  1171. X            if ((x < x_A4_min) || (x > x_A4_max) || (y < y_A4_min) || (y > y_A4_max))
  1172. X            {
  1173. X                left();
  1174. X                prepare_top_stack_object();
  1175. X                return;
  1176. X            }
  1177. X            draw_coords(pboard, (caddr_t) x, (caddr_t) y);
  1178. X
  1179. X        } while (!((mask & btn3) || (mask & btn2) || (mask & btn1)));
  1180. X
  1181. X        do
  1182. X        {
  1183. X            PointerPosition(&h, &v, &mask2);
  1184. X        } while ((mask2 & btn3));
  1185. X
  1186. X
  1187. X        prepare_top_stack_object();
  1188. X
  1189. X        if (mask & btn1)
  1190. X            pick_edit();
  1191. X        else if (mask & btn2)
  1192. X            index = pick_move(x, y);
  1193. X        else
  1194. X        {    /* more */
  1195. X            index = nextObject();
  1196. X
  1197. X            if (index == -1)
  1198. X            {    /* no objects found */
  1199. X                left();
  1200. X                leave_pick("No valid object found !");
  1201. X                return;
  1202. X            }
  1203. X        }
  1204. X
  1205. X    }    /* while */
  1206. }
  1207. X
  1208. X
  1209. X
  1210. int
  1211. pick_move(int startx, int starty)
  1212. {
  1213. X    /* currIndex points to object-reference in global database */
  1214. X
  1215. X    struct fig1    *one;
  1216. X    struct fig2    *two;
  1217. X    struct fig3    *three;
  1218. X    struct fig4    *four;
  1219. X    struct fig6    *six;    
  1220. X    int             x, y, h, v, oldh, oldv;
  1221. X    unsigned int    mask;
  1222. X    Display        *disp = XtDisplay(pboard);
  1223. X    Window          win = XtWindow(pboard);
  1224. X    int             btn1 = 256, btn2 = 512, btn3 = 1024;
  1225. X    float           ax, bx, ay, by, sx, sy;
  1226. X    int             rad;
  1227. X    float           zoomx, zoomy, zoomh, zoomv, zoomsx, zoomsy;
  1228. X    Boolean         redraw;
  1229. X    int             snapx, snapy;
  1230. X
  1231. X
  1232. X    by = -999.0;
  1233. X    oldh = -999;
  1234. X    oldv = oldh;
  1235. X
  1236. X
  1237. X    do
  1238. X    {
  1239. X        PointerPosition(&x, &y, &mask);
  1240. X
  1241. X        draw_coords(pboard, (caddr_t) x, (caddr_t) y);
  1242. X
  1243. X        switch (kind[currIndex])
  1244. X        {
  1245. X        case 'I':
  1246. X            six = (struct fig6 *) obj[currIndex];
  1247. X            h = x - startx;
  1248. X            v = y - starty;
  1249. X            if ((oldh != h) || (oldv != v))
  1250. X            {
  1251. X                oldh = h;
  1252. X                oldv = v;
  1253. X                zoomx = six->ax;
  1254. X                zoomy = six->ay;
  1255. X                zoomh = six->ex;
  1256. X                zoomv = six->ey;
  1257. X                zoomsx = six->sx;
  1258. X                zoomsy = six->sy;
  1259. X                
  1260. X                if (zoomed == True) real2zoomed(&zoomsx, &zoomsy);
  1261. X                
  1262. X                /* delete old line */
  1263. X                if (by == -999.0)
  1264. X                    DrawBezier(zoomx, zoomy, zoomh, zoomv, zoomsx, zoomsy);
  1265. X                else
  1266. X                    DrawBezier(ax, ay, bx, by, sx, sy);
  1267. X                    
  1268. X                if (zoomed == True) 
  1269. X                {
  1270. X                    real2zoomed(&zoomx, &zoomy);
  1271. X                    real2zoomed(&zoomh, &zoomv);
  1272. X                }
  1273. X                ax = zoomx + (float) h;
  1274. X                ay = zoomy + (float) v;
  1275. X                bx = zoomh + (float) h;
  1276. X                by = zoomv + (float) v;
  1277. X                sx = zoomsx + (float) h;
  1278. X                sy = zoomsy + (float) v;
  1279. X
  1280. X                if ((snap == True) && (raster == True))
  1281. X                {
  1282. X                    snapx = (int) ax;
  1283. X                    snapy = (int) ay;
  1284. X                    valid_snap_coords(&snapx, &snapy);
  1285. X                    bx -= (ax - (float) snapx);
  1286. X                    by -= (ay - (float) snapy);
  1287. X                    sx -= (ax - (float) snapx);
  1288. X                    sy -= (ay - (float) snapy);
  1289. X                    ax = (float) snapx;
  1290. X                    ay = (float) snapy;
  1291. X                }
  1292. X                /* draw new line */
  1293. X                
  1294. X                if (zoomed==True)
  1295. X                {
  1296. X                    zoomed2real(&ax,&ay);
  1297. X                    zoomed2real(&bx,&by);
  1298. X                }
  1299. X                
  1300. X                DrawBezier(ax, ay, bx, by, sx, sy);
  1301. X            }
  1302. X            break;
  1303. X
  1304. X        case 'L':
  1305. X            two = (struct fig2 *) obj[currIndex];
  1306. X            h = x - startx;
  1307. X            v = y - starty;
  1308. X            if ((oldh != h) || (oldv != v))
  1309. X            {
  1310. X                oldh = h;
  1311. X                oldv = v;
  1312. X                zoomx = two->x;
  1313. X                zoomy = two->y;
  1314. X                zoomh = two->h;
  1315. X                zoomv = two->v;
  1316. X                if (zoomed == True)
  1317. X                {
  1318. X                    real2zoomed(&zoomx, &zoomy);
  1319. X                    real2zoomed(&zoomh, &zoomv);
  1320. X                }
  1321. X                /* delete old line */
  1322. X                if (by == -999.0)
  1323. X                    XDrawLine(disp, win, gc, (int) zoomx, (int) zoomy,
  1324. X                          (int) zoomh, (int) zoomv);
  1325. X                else
  1326. X                    XDrawLine(disp, win, gc, (int) ax, (int) ay,
  1327. X                          (int) bx, (int) by);
  1328. X                ax = zoomx + (float) h;
  1329. X                ay = zoomy + (float) v;
  1330. X                bx = zoomh + (float) h;
  1331. X                by = zoomv + (float) v;
  1332. X
  1333. X                if ((snap == True) && (raster == True))
  1334. X                {
  1335. X                    snapx = (int) ax;
  1336. X                    snapy = (int) ay;
  1337. X                    valid_snap_coords(&snapx, &snapy);
  1338. X                    bx -= (ax - (float) snapx);
  1339. X                    by -= (ay - (float) snapy);
  1340. X                    ax = (float) snapx;
  1341. X                    ay = (float) snapy;
  1342. X                }
  1343. X                /* draw new line */
  1344. X                XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1345. X            }
  1346. X            break;
  1347. X
  1348. X        case 'V':
  1349. X            h = x - startx;
  1350. X            v = y - starty;
  1351. X            if ((oldh != h) || (oldv != v))
  1352. X            {
  1353. X                oldh = h;
  1354. X                oldv = v;
  1355. X                two = (struct fig2 *) obj[currIndex];
  1356. X                zoomx = two->x;
  1357. X                zoomy = two->y;
  1358. X                zoomh = two->h;
  1359. X                zoomv = two->v;
  1360. X                if (zoomed == True)
  1361. X                {
  1362. X                    real2zoomed(&zoomx, &zoomy);
  1363. X                    real2zoomed(&zoomh, &zoomv);
  1364. X                }
  1365. X                if (by == -999.0)
  1366. X                {
  1367. X                    XDrawLine(disp, win, gc, (int) zoomx, (int) zoomy,
  1368. X                          (int) zoomh, (int) zoomv);
  1369. X                    draw_vector_marker(zoomx, zoomy, zoomh, zoomv);
  1370. X                } else
  1371. X                {
  1372. X                    XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1373. X                    draw_vector_marker(ax, ay, bx, by);
  1374. X                }
  1375. X                ax = zoomx + (float) h;
  1376. X                ay = zoomy + (float) v;
  1377. X                bx = zoomh + (float) h;
  1378. X                by = zoomv + (float) v;
  1379. X
  1380. X                if ((snap == True) && (raster == True))
  1381. X                {
  1382. X                    snapx = (int) ax;
  1383. X                    snapy = (int) ay;
  1384. X                    valid_snap_coords(&snapx, &snapy);
  1385. X                    bx -= (ax - (float) snapx);
  1386. X                    by -= (ay - (float) snapy);
  1387. X                    ax = (float) snapx;
  1388. X                    ay = (float) snapy;
  1389. X                }
  1390. X                XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1391. X                draw_vector_marker(ax, ay, bx, by);
  1392. X            }
  1393. X            break;
  1394. X
  1395. X        case 'N':
  1396. X            h = x - startx;
  1397. X            v = y - starty;
  1398. X            if ((oldh != h) || (oldv != v))
  1399. X            {
  1400. X                oldh = h;
  1401. X                oldv = v;
  1402. X                three = (struct fig3 *) obj[currIndex];
  1403. X                zoomx = three->x;
  1404. X                zoomy = three->y;
  1405. X                zoomh = three->h;
  1406. X                zoomv = three->v;
  1407. X                if (zoomed == True)
  1408. X                {
  1409. X                    real2zoomed(&zoomx, &zoomy);
  1410. X                    real2zoomed(&zoomh, &zoomv);
  1411. X                }
  1412. X                if (by == -999.0)
  1413. X                {
  1414. X                    XDrawRectangle(disp, win, gc, (int) zoomx, (int) zoomy,
  1415. X                         (unsigned int) (zoomh - zoomx),
  1416. X                        (unsigned int) (zoomv - zoomy));
  1417. X                    print_box_text(three->textpos, zoomx, zoomy, zoomh, zoomv, three->text);
  1418. X                } else
  1419. X                {
  1420. X                    XDrawRectangle(disp, win, gc, ax, ay,
  1421. X                           (unsigned int) (bx - ax),
  1422. X                          (unsigned int) (by - ay));
  1423. X                    XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1424. X                    XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1425. X                }
  1426. X                ax = zoomx + (float) h;
  1427. X                ay = zoomy + (float) v;
  1428. X                bx = zoomh + (float) h;
  1429. X                by = zoomv + (float) v;
  1430. X
  1431. X                if ((snap == True) && (raster == True))
  1432. X                {
  1433. X                    snapx = (int) ax;
  1434. X                    snapy = (int) ay;
  1435. X                    valid_snap_coords(&snapx, &snapy);
  1436. X                    bx -= (ax - (float) snapx);
  1437. X                    by -= (ay - (float) snapy);
  1438. X                    ax = (float) snapx;
  1439. X                    ay = (float) snapy;
  1440. X                }
  1441. X                XDrawRectangle(disp, win, gc, ax, ay,
  1442. X                           (unsigned int) (bx - ax),
  1443. X                           (unsigned int) (by - ay));
  1444. X                XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1445. X                XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1446. X            }
  1447. X            break;
  1448. X
  1449. X        case 'D':
  1450. X            h = x - startx;
  1451. X            v = y - starty;
  1452. X            if ((h != oldh) || (v != oldv))
  1453. X            {
  1454. X                oldh = h;
  1455. X                oldv = v;
  1456. X                four = (struct fig4 *) obj[currIndex];
  1457. X                zoomx = four->x;
  1458. X                zoomy = four->y;
  1459. X                zoomh = four->h;
  1460. X                zoomv = four->v;
  1461. X                XSetLineAttributes(disp, gc, 0, LineOnOffDash, CapButt, JoinMiter);
  1462. X                if (zoomed == True)
  1463. X                {
  1464. X                    real2zoomed(&zoomx, &zoomy);
  1465. X                    real2zoomed(&zoomh, &zoomv);
  1466. X                }
  1467. X                if (by == -999.0)
  1468. X                {
  1469. X                    XDrawRectangle(disp, win, gc, (int) zoomx, (int) zoomy,
  1470. X                         (unsigned int) (zoomh - zoomx),
  1471. X                        (unsigned int) (zoomv - zoomy));
  1472. X                    print_box_text(four->textpos, zoomx, zoomy, zoomh, zoomv, four->text);
  1473. X                } else
  1474. X                {
  1475. X                    XDrawRectangle(disp, win, gc, (int) ax, (int) ay,
  1476. X                           (unsigned int) (bx - ax),
  1477. X                          (unsigned int) (by - ay));
  1478. X                    XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1479. X                    XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1480. X                }
  1481. X                ax = zoomx + (float) h;
  1482. X                ay = zoomy + (float) v;
  1483. X                bx = zoomh + (float) h;
  1484. X                by = zoomv + (float) v;
  1485. X
  1486. X                if ((snap == True) && (raster == True))
  1487. X                {
  1488. X                    snapx = (int) ax;
  1489. X                    snapy = (int) ay;
  1490. X                    valid_snap_coords(&snapx, &snapy);
  1491. X                    bx -= (ax - (float) snapx);
  1492. X                    by -= (ay - (float) snapy);
  1493. X                    ax = (float) snapx;
  1494. X                    ay = (float) snapy;
  1495. X                }
  1496. X                XDrawRectangle(disp, win, gc, (int) ax, (int) ay,
  1497. X                           (unsigned int) (bx - ax),
  1498. X                           (unsigned int) (by - ay));
  1499. X                XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1500. X                XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1501. X                XSetLineAttributes(disp, gc, 0, LineSolid, CapButt, JoinMiter);
  1502. X            }
  1503. X            break;
  1504. X
  1505. X        case 'F':
  1506. X            h = x - startx;
  1507. X            v = y - starty;
  1508. X            if ((oldh != h) || (oldv != v))
  1509. X            {
  1510. X                oldh = h;
  1511. X                oldv = v;
  1512. X                two = (struct fig2 *) obj[currIndex];
  1513. X                zoomx = two->x;
  1514. X                zoomy = two->y;
  1515. X                zoomh = two->h;
  1516. X                zoomv = two->v;
  1517. X                if (zoomed == True)
  1518. X                {
  1519. X                    real2zoomed(&zoomx, &zoomy);
  1520. X                    real2zoomed(&zoomh, &zoomv);
  1521. X                }
  1522. X                if (by == -999.0)
  1523. X                {
  1524. X                    XFillRectangle(disp, win, gc, (int) zoomx, (int) zoomy,
  1525. X                         (unsigned int) (zoomh - zoomx),
  1526. X                        (unsigned int) (zoomv - zoomy));
  1527. X                } else
  1528. X                {
  1529. X                    XDrawRectangle(disp, win, gc, (int) ax, (int) ay,
  1530. X                           (unsigned int) (bx - ax),
  1531. X                          (unsigned int) (by - ay));
  1532. X                    XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1533. X                    XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1534. X                }
  1535. X                ax = zoomx + (float) h;
  1536. X                ay = zoomy + (float) v;
  1537. X                bx = zoomh + (float) h;
  1538. X                by = zoomv + (float) v;
  1539. X
  1540. X                if ((snap == True) && (raster == True))
  1541. X                {
  1542. X                    snapx = (int) ax;
  1543. X                    snapy = (int) ay;
  1544. X                    valid_snap_coords(&snapx, &snapy);
  1545. X                    bx -= (ax - (float) snapx);
  1546. X                    by -= (ay - (float) snapy);
  1547. X                    ax = (float) snapx;
  1548. X                    ay = (float) snapy;
  1549. X                }
  1550. X                XDrawRectangle(disp, win, gc, (int) ax, (int) ay,
  1551. X                           (unsigned int) (bx - ax),
  1552. X                           (unsigned int) (by - ay));
  1553. X                XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1554. X                XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1555. X            }
  1556. X            break;
  1557. X
  1558. X        case 'C':
  1559. X            h = x - startx;
  1560. X            v = y - starty;
  1561. X            if ((oldh != h) || (oldv != v))
  1562. X            {
  1563. X                oldh = h;
  1564. X                oldv = v;
  1565. X                two = (struct fig2 *) obj[currIndex];
  1566. X                zoomx = two->x;
  1567. X                zoomy = two->y;
  1568. X                rad = two->radius;
  1569. X                if (zoomed == True)
  1570. X                {
  1571. X                    real2zoomed(&zoomx, &zoomy);
  1572. X                    real2zoomed(&zoomh, &zoomv);
  1573. X                    rad *= 10;
  1574. X                }
  1575. X                if (by == -999.0)
  1576. X                {
  1577. X                    XDrawArc(disp, win, gc, (int) zoomx - rad,
  1578. X                         (int) zoomy - rad,
  1579. X                         (unsigned int) (rad + rad),
  1580. X                         (unsigned int) (rad + rad), 0, 64 * 360);
  1581. X                    by = 0;
  1582. X                } else
  1583. X                {
  1584. X                    XDrawArc(disp, win, gc, (int) (ax - (float) rad),
  1585. X                         (int) (ay - (float) rad),
  1586. X                         (unsigned int) (rad + rad),
  1587. X                         (unsigned int) (rad + rad), 0, 64 * 360);
  1588. X                    XDrawLine(disp, win, gc, ax, ay - rad, ax, ay + rad);
  1589. X                    XDrawLine(disp, win, gc, ax - rad, ay, ax + rad, ay);
  1590. X                }
  1591. X                ax = zoomx + (float) h;
  1592. X                ay = zoomy + (float) v;
  1593. X
  1594. X                if ((snap == True) && (raster == True))
  1595. X                {
  1596. X                    snapx = (int) ax;
  1597. X                    snapy = (int) ay;
  1598. X                    valid_snap_coords(&snapx, &snapy);
  1599. X                    ax = (float) snapx;
  1600. X                    ay = (float) snapy;
  1601. X                }
  1602. X                XDrawArc(disp, win, gc, (int) (ax - (float) rad),
  1603. X                     (int) (ay - (float) rad),
  1604. X                     (unsigned int) (rad + rad),
  1605. X                   (unsigned int) (rad + rad), 0, 64 * 360);
  1606. X                XDrawLine(disp, win, gc, (int) ax, (int) ay - rad, (int) ax, (int) ay + rad);
  1607. X                XDrawLine(disp, win, gc, (int) ax - rad, (int) ay, (int) ax + rad, (int) ay);
  1608. X            }
  1609. X            break;
  1610. X
  1611. X        case 'B':
  1612. X            h = x - startx;
  1613. X            v = y - starty;
  1614. X            if ((oldh != h) || (oldv != v))
  1615. X            {
  1616. X                oldh = h;
  1617. X                oldv = v;
  1618. X                two = (struct fig2 *) obj[currIndex];
  1619. X                zoomx = two->x;
  1620. X                zoomy = two->y;
  1621. X                rad = two->radius;
  1622. X                if (zoomed == True)
  1623. X                {
  1624. X                    real2zoomed(&zoomx, &zoomy);
  1625. X                    real2zoomed(&zoomh, &zoomv);
  1626. X                    rad *= 10;
  1627. X                }
  1628. X                if (by == -999.0)
  1629. X                {
  1630. X                    XFillArc(disp, win, gc, (int) zoomx - rad, (int) zoomy - rad,
  1631. X                         (unsigned int) (rad + rad),
  1632. X                         (unsigned int) (rad + rad), 0, 64 * 360);
  1633. X                    by = 0;
  1634. X                } else
  1635. X                {
  1636. X                    XDrawArc(disp, win, gc, (int) (ax - (float) rad),
  1637. X                         (int) (ay - (float) rad),
  1638. X                         (unsigned int) (rad + rad),
  1639. X                         (unsigned int) (rad + rad), 0, 64 * 360);
  1640. X                    XDrawLine(disp, win, gc, (int) ax, (int) ay - rad, (int) ax, (int) ay + rad);
  1641. X                    XDrawLine(disp, win, gc, (int) ax - rad, (int) ay, (int) ax + rad, (int) ay);
  1642. X                }
  1643. X                ax = zoomx + (float) h;
  1644. X                ay = zoomy + (float) v;
  1645. X
  1646. X                if ((snap == True) && (raster == True))
  1647. X                {
  1648. X                    snapx = (int) ax;
  1649. X                    snapy = (int) ay;
  1650. X                    valid_snap_coords(&snapx, &snapy);
  1651. X                    ax = (float) snapx;
  1652. X                    ay = (float) snapy;
  1653. X                }
  1654. X                XDrawArc(disp, win, gc, (int) (ax - (float) rad),
  1655. X                     (int) (ay - (float) rad),
  1656. X                     (unsigned int) (rad + rad),
  1657. X                   (unsigned int) (rad + rad), 0, 64 * 360);
  1658. X                XDrawLine(disp, win, gc, (int) ax, (int) ay - rad, (int) ax, (int) ay + rad);
  1659. X                XDrawLine(disp, win, gc, (int) ax - rad, (int) ay, (int) ax + rad, (int) ay);
  1660. X            }
  1661. X            break;
  1662. X
  1663. X        case 'O':
  1664. X            h = x - startx;
  1665. X            v = y - starty;
  1666. X            if ((oldh != h) || (oldv != v))
  1667. X            {
  1668. X                oldh = h;
  1669. X                oldv = v;
  1670. X                one = (struct fig1 *) obj[currIndex];
  1671. X                zoomx = one->x;
  1672. X                zoomy = one->y;
  1673. X                zoomh = one->h;
  1674. X                zoomv = one->v;
  1675. X                if (zoomed == True)
  1676. X                {
  1677. X                    real2zoomed(&zoomx, &zoomy);
  1678. X                    real2zoomed(&zoomh, &zoomv);
  1679. X                }
  1680. X                if (by == -999.0)
  1681. X                    DrawOval((int) zoomx, (int) zoomy, (int) zoomh, (int) zoomv);
  1682. X                else
  1683. X                {
  1684. X                    DrawOval((int) ax, (int) ay, (int) bx, (int) by);
  1685. X                    XDrawLine(disp, win, gc, (int) (ax + (bx - ax) / 2), (int) ay, (int) (ax + (bx - ax) / 2), by);
  1686. X                    XDrawLine(disp, win, gc, (int) ax, (int) (ay + (by - ay) / 2), (int) bx, (int) (ay + (by - ay) / 2));
  1687. X                }
  1688. X                ax = zoomx + (float) h;
  1689. X                ay = zoomy + (float) v;
  1690. X                bx = zoomh + (float) h;
  1691. X                by = zoomv + (float) v;
  1692. X
  1693. X                if ((snap == True) && (raster == True))
  1694. X                {
  1695. X                    snapx = (int) ax;
  1696. X                    snapy = (int) ay;
  1697. X                    valid_snap_coords(&snapx, &snapy);
  1698. X                    bx -= (ax - (float) snapx);
  1699. X                    by -= (ay - (float) snapy);
  1700. X                    ax = (float) snapx;
  1701. X                    ay = (float) snapy;
  1702. X                }
  1703. X                DrawOval((int) ax, (int) ay, (int) bx, (int) by);
  1704. X                XDrawLine(disp, win, gc, (int) (ax + (bx - ax) / 2), (int) ay, (int) (ax + (bx - ax) / 2), by);
  1705. X                XDrawLine(disp, win, gc, (int) ax, (int) (ay + (by - ay) / 2), (int) bx, (int) (ay + (by - ay) / 2));
  1706. X            }
  1707. X            break;
  1708. X
  1709. X        default:
  1710. X            break;
  1711. X
  1712. X        }    /* switch */
  1713. X    } while ((mask & btn2));    /* || ( (graph_action=='Y') && (mask & btn1) ) ); */
  1714. X
  1715. X
  1716. X    if ((x < x_A4_min) || (x > x_A4_max) || (y < y_A4_min) || (y > y_A4_max))
  1717. X    {    /* cancel */
  1718. X        if ((refr_auto == True) && (graph_action != 'Y'))
  1719. X            refresh(pboard, '?', (caddr_t)DUMMY);
  1720. X        return -1;
  1721. X    }
  1722. X    /* store the new position of the object */
  1723. X
  1724. X    switch (kind[currIndex])
  1725. X    {
  1726. X    case 'I':
  1727. X        six = (struct fig6 *) obj[currIndex];
  1728. X        if (zoomed == True) zoomed2real(&sx, &sy);
  1729. X        six->ax = ax;
  1730. X        six->ay = ay;
  1731. X        six->ex = bx;
  1732. X        six->ey = by;
  1733. X        six->sx = sx;
  1734. X        six->sy = sy;
  1735. X        break;
  1736. X
  1737. X    case 'L':
  1738. X        two = (struct fig2 *) obj[currIndex];
  1739. X        if (zoomed == True)
  1740. X        {
  1741. X            zoomed2real(&ax, &ay);
  1742. X            zoomed2real(&bx, &by);
  1743. X        }
  1744. X        two->x = ax;
  1745. X        two->y = ay;
  1746. X        two->h = bx;
  1747. X        two->v = by;
  1748. X        break;
  1749. X
  1750. X    case 'V':
  1751. X        two = (struct fig2 *) obj[currIndex];
  1752. X        if (zoomed == True)
  1753. X        {
  1754. X            zoomed2real(&ax, &ay);
  1755. X            zoomed2real(&bx, &by);
  1756. X        }
  1757. X        two->x = ax;
  1758. X        two->y = ay;
  1759. X        two->h = bx;
  1760. X        two->v = by;
  1761. X        break;
  1762. X
  1763. X
  1764. X    case 'N':
  1765. X        three = (struct fig3 *) obj[currIndex];
  1766. X        XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1767. X        XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1768. X        zoomx = ax;
  1769. X        zoomy = ay;
  1770. X        zoomh = bx;
  1771. X        zoomv = by;
  1772. X        if (zoomed == True)
  1773. X        {
  1774. X            zoomed2real(&zoomx, &zoomy);
  1775. X            zoomed2real(&zoomh, &zoomv);
  1776. X        }
  1777. X        three->x = zoomx;
  1778. X        three->y = zoomy;
  1779. X        three->h = zoomh;
  1780. X        three->v = zoomv;
  1781. X        print_box_text(three->textpos, zoomx, zoomy, zoomh, zoomv, three->text);
  1782. X        break;
  1783. X
  1784. X    case 'D':
  1785. X        four = (struct fig4 *) obj[currIndex];
  1786. X        XSetLineAttributes(disp, gc, 0, LineOnOffDash, CapButt, JoinMiter);
  1787. X        XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1788. X        XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1789. X        XSetLineAttributes(disp, gc, 0, LineSolid, CapButt, JoinMiter);
  1790. X        zoomx = ax;
  1791. X        zoomy = ay;
  1792. X        zoomh = bx;
  1793. X        zoomv = by;
  1794. X        if (zoomed == True)
  1795. X        {
  1796. X            zoomed2real(&zoomx, &zoomy);
  1797. X            zoomed2real(&zoomh, &zoomv);
  1798. X        }
  1799. X        four->x = zoomx;
  1800. X        four->y = zoomy;
  1801. X        four->h = zoomh;
  1802. X        four->v = zoomv;
  1803. X        print_box_text(four->textpos, zoomx, zoomy, zoomh, zoomv, four->text);
  1804. X        break;
  1805. X
  1806. X    case 'F':
  1807. X        two = (struct fig2 *) obj[currIndex];
  1808. X        XDrawLine(disp, win, gc, (int) ax, (int) ay, (int) bx, (int) by);
  1809. X        XDrawLine(disp, win, gc, (int) ax, (int) by, (int) bx, (int) ay);
  1810. X        XDrawRectangle(disp, win, gc, (int) ax, (int) ay,
  1811. X                   (unsigned int) (bx - ax),
  1812. X                   (unsigned int) (by - ay));
  1813. X        XFillRectangle(disp, win, gc, (int) ax, (int) ay,
  1814. X                   (unsigned int) (bx - ax),
  1815. X                   (unsigned int) (by - ay));
  1816. X        zoomx = ax;
  1817. X        zoomy = ay;
  1818. X        zoomh = bx;
  1819. X        zoomv = by;
  1820. X        if (zoomed == True)
  1821. X        {
  1822. X            zoomed2real(&zoomx, &zoomy);
  1823. X            zoomed2real(&zoomh, &zoomv);
  1824. X        }
  1825. X        two->x = zoomx;
  1826. X        two->y = zoomy;
  1827. X        two->h = zoomh;
  1828. X        two->v = zoomv;
  1829. X        break;
  1830. X
  1831. X    case 'C':
  1832. X        two = (struct fig2 *) obj[currIndex];
  1833. X        XDrawLine(disp, win, gc, (int) ax - rad, (int) ay, (int) ax + rad, (int) ay);
  1834. X        XDrawLine(disp, win, gc, (int) ax, (int) ay - rad, (int) ax, (int) ay + rad);
  1835. X        zoomx = ax;
  1836. X        zoomy = ay;
  1837. X        if (zoomed == True)
  1838. X        {
  1839. X            zoomed2real(&zoomx, &zoomy);
  1840. X            zoomed2real(&zoomh, &zoomv);
  1841. X        }
  1842. X        two->x = zoomx;
  1843. X        two->y = zoomy;
  1844. X        break;
  1845. X
  1846. X    case 'B':
  1847. X        two = (struct fig2 *) obj[currIndex];
  1848. X        XDrawLine(disp, win, gc, (int) ax - rad, (int) ay, (int) ax + rad, (int) ay);
  1849. X        XDrawLine(disp, win, gc, (int) ax, (int) ay - rad, (int) ax, (int) ay + rad);
  1850. X        XDrawArc(disp, win, gc, (int) ax - rad, (int) ay - rad,
  1851. X             (unsigned int) (rad + rad),
  1852. X             (unsigned int) (rad + rad), 0, 64 * 360);
  1853. X        XFillArc(disp, win, gc, (int) ax - rad, (int) ay - rad,
  1854. X             (unsigned int) (rad + rad),
  1855. X             (unsigned int) (rad + rad), 0, 64 * 360);
  1856. X        zoomx = ax;
  1857. X        zoomy = ay;
  1858. X        if (zoomed == True)
  1859. X        {
  1860. X            zoomed2real(&zoomx, &zoomy);
  1861. X            zoomed2real(&zoomh, &zoomv);
  1862. X        }
  1863. X        two->x = zoomx;
  1864. X        two->y = zoomy;
  1865. X        break;
  1866. X
  1867. X    case 'O':
  1868. X        one = (struct fig1 *) obj[currIndex];
  1869. X        XDrawLine(disp, win, gc, (int) (ax + (bx - ax) / 2), (int) ay,
  1870. X              (int) (ax + (bx - ax) / 2), (int) by);
  1871. X        XDrawLine(disp, win, gc, (int) ax, (int) (ay + (by - ay) / 2),
  1872. X              (int) bx, (int) (ay + (by - ay) / 2));
  1873. X        zoomx = ax;
  1874. X        zoomy = ay;
  1875. X        zoomh = bx;
  1876. X        zoomv = by;
  1877. X        if (zoomed == True)
  1878. X        {
  1879. X            zoomed2real(&zoomx, &zoomy);
  1880. X            zoomed2real(&zoomh, &zoomv);
  1881. X        }
  1882. X        one->x = zoomx;
  1883. X        one->y = zoomy;
  1884. X        one->h = zoomh;
  1885. X        one->v = zoomv;
  1886. X        break;
  1887. X
  1888. X
  1889. X    default:
  1890. X        break;
  1891. X
  1892. X    }    /* switch */
  1893. X
  1894. X
  1895. X
  1896. X
  1897. X    if (refr_auto == True)
  1898. X        refresh(pboard, '?', (caddr_t)DUMMY);
  1899. X
  1900. X    return 0;
  1901. X
  1902. X
  1903. }
  1904. X
  1905. X
  1906. void
  1907. pick_edit()
  1908. {
  1909. X    /* currIndex points to object-reference in global database */
  1910. X    /* button 1 is pressed */
  1911. X
  1912. X    struct fig1    *one;
  1913. X    struct fig2    *two;
  1914. X    struct fig3    *three;
  1915. X    struct fig4    *four;
  1916. X    struct fig6    *six;
  1917. X    int             x, y, dist1, dist2, dist3, dist4, low_val;
  1918. X    unsigned int    mask;
  1919. X    double          vec_x, vec_y, vec_h, vec_v;
  1920. X    int             res1, res2;
  1921. X    float           h_pos, v_pos, x_pos, y_pos;
  1922. X    float           h, v;
  1923. X
  1924. X
  1925. X
  1926. X
  1927. X
  1928. X    PointerPosition(&x, &y, &mask);
  1929. X
  1930. X
  1931. X    if (zoomed == True)
  1932. X    {
  1933. X        h = (float) x;
  1934. X        v = (float) y;
  1935. X        zoomed2real(&h, &v);
  1936. X        x = (int) h;
  1937. X        y = (int) v;
  1938. X    }
  1939. X    switch (kind[currIndex])
  1940. X    {
  1941. X    case 'I':    /* which point ? */
  1942. X        six = (struct fig6 *) obj[currIndex];
  1943. X        dist1 = calc_distance(x, y, (int) six->ax, (int) six->ay);    /* ax,ay */
  1944. X        dist2 = calc_distance(x, y, (int) six->ex, (int) six->ey);    /* ex,ey */
  1945. X        dist3 = calc_distance(x, y, (int) six->sx, (int) six->sy);    /* sx,sy */
  1946. X        if (zoomed == True)
  1947. X        {
  1948. X            dist1 *= 10;
  1949. X            dist2 *= 10;
  1950. X            dist3 *= 10;
  1951. X        }
  1952. X        /* compute minimum */
  1953. X        low_val=(dist1<dist2) ? dist1 : dist2;
  1954. X        low_val=(low_val<dist3) ? low_val : dist3;
  1955. X        if (low_val<=points)
  1956. X        { /* buttonpress was inside of circle */
  1957. X        if (low_val==dist1) edit_bezier_curveA();
  1958. X            else if (low_val==dist2) edit_bezier_curveE();
  1959. X            else edit_bezier_curveS();    
  1960. X
  1961. X            if (refr_auto == True)
  1962. X                refresh(pboard, '?', (caddr_t)DUMMY);    /* wipe screen */
  1963. X        }    /* if low_val<=points */
  1964. X        break;
  1965. X
  1966. X    case 'L':    /* edit which endpoint ? */
  1967. X        two = (struct fig2 *) obj[currIndex];
  1968. X        vec_x = (double) two->x - (double) x;
  1969. X        vec_y = (double) two->y - (double) y;
  1970. X        vec_h = (double) two->h - (double) x;
  1971. X        vec_v = (double) two->v - (double) y;
  1972. X        res1 = abs((int) sqrt(vec_x * vec_x + vec_y * vec_y));
  1973. X        res2 = abs((int) sqrt(vec_h * vec_h + vec_v * vec_v));
  1974. X        if (zoomed == True)
  1975. X        {
  1976. X            res1 = res1 * 10;
  1977. X            res2 = res2 * 10;
  1978. X        }
  1979. X        if ((res1 <= points) || (res2 <= points))
  1980. X        {
  1981. X            if (res1 < res2)
  1982. X            {
  1983. X                edit_x_line();
  1984. X                if (refr_auto == True)
  1985. X                    refresh(pboard, '?', (caddr_t)DUMMY);    /* wipe screen */
  1986. X            } else
  1987. X            {
  1988. X                edit_y_line();
  1989. X                if (refr_auto == True)
  1990. X                    refresh(pboard, '?', (caddr_t)DUMMY);    /* wipe screen */
  1991. X            }
  1992. X        }
  1993. X        break;
  1994. X
  1995. X    case 'V':    /* edit which endpoint ? */
  1996. X        two = (struct fig2 *) obj[currIndex];
  1997. X        vec_x = (double) two->x - (double) x;
  1998. X        vec_y = (double) two->y - (double) y;
  1999. X        vec_h = (double) two->h - (double) x;
  2000. X        vec_v = (double) two->v - (double) y;
  2001. X        res1 = abs((int) sqrt(vec_x * vec_x + vec_y * vec_y));
  2002. X        res2 = abs((int) sqrt(vec_h * vec_h + vec_v * vec_v));
  2003. X        if (zoomed == True)
  2004. X        {
  2005. X            res1 = res1 * 10;
  2006. X            res2 = res2 * 10;
  2007. X        }
  2008. X        if ((res1 <= points) || (res2 <= points))
  2009. X        {
  2010. X            if (res1 < res2)
  2011. X                edit_x_vector();
  2012. X            else
  2013. X                edit_y_vector();
  2014. X        }
  2015. X        break;
  2016. X
  2017. X    case 'N':    /* which point ? */
  2018. X        three = (struct fig3 *) obj[currIndex];
  2019. X        dist1 = calc_distance(x, y, (int) three->x, (int) three->y);    /* upper left */
  2020. X        dist2 = calc_distance(x, y, (int) three->h, (int) three->v);    /* lower right */
  2021. X        dist3 = calc_distance(x, y, (int) three->h, (int) three->y);    /* upper right */
  2022. X        dist4 = calc_distance(x, y, (int) three->x, (int) three->v);    /* lower left */
  2023. X        if (zoomed == True)
  2024. X        {
  2025. X            dist1 *= 10;
  2026. X            dist2 *= 10;
  2027. X            dist3 *= 10;
  2028. X            dist4 *= 10;
  2029. X        }
  2030. X        /* compute minimum */
  2031. X        if (dist1 < dist2)
  2032. X            low_val = dist1;
  2033. X        else
  2034. X            low_val = dist2;
  2035. X        if (dist3 < low_val)
  2036. X            low_val = dist3;
  2037. X        if (dist4 < low_val)
  2038. X            low_val = dist4;
  2039. X        if (low_val <= points)
  2040. X        {
  2041. X            x_pos = three->x;
  2042. X            y_pos = three->y;
  2043. X            h_pos = three->h;
  2044. X            v_pos = three->v;
  2045. X            if (low_val == dist1)
  2046. X            {
  2047. X                three->x = h_pos;
  2048. X                three->y = v_pos;
  2049. X                three->h = x_pos;
  2050. X                three->v = y_pos;
  2051. X                /*
  2052. X                 * now, coordinates are in the correct
  2053. X                 * order...
  2054. X                 */
  2055. X            } else if (low_val == dist3)
  2056. X            {
  2057. X                three->y = v_pos;
  2058. X                three->v = y_pos;
  2059. X            } else if (low_val == dist4)
  2060. X            {
  2061. X                three->x = h_pos;
  2062. X                three->h = x_pos;
  2063. X            }
  2064. X            /* low_val==dist2 is default... */
  2065. X            edit_frame(nn);
  2066. X            if (refr_auto == True)
  2067. X                refresh(pboard, '?', (caddr_t)DUMMY);    /* wipe screen */
  2068. X        }    /* if low_val<=points */
  2069. X        break;
  2070. X
  2071. X
  2072. X    case 'F':    /* which point ? */
  2073. X        two = (struct fig2 *) obj[currIndex];
  2074. X        dist1 = calc_distance(x, y, (int) two->x, (int) two->y);    /* upper left */
  2075. X        dist2 = calc_distance(x, y, (int) two->h, (int) two->v);    /* lower right */
  2076. X        dist3 = calc_distance(x, y, (int) two->h, (int) two->y);    /* upper right */
  2077. X        dist4 = calc_distance(x, y, (int) two->x, (int) two->v);    /* lower left */
  2078. X        if (zoomed == True)
  2079. X        {
  2080. X            dist1 *= 10;
  2081. X            dist2 *= 10;
  2082. X            dist3 *= 10;
  2083. X            dist4 *= 10;
  2084. X        }
  2085. X        /* compute minimum */
  2086. X        if (dist1 < dist2)
  2087. X            low_val = dist1;
  2088. X        else
  2089. X            low_val = dist2;
  2090. X        if (dist3 < low_val)
  2091. X            low_val = dist3;
  2092. X        if (dist4 < low_val)
  2093. X            low_val = dist4;
  2094. X        if (low_val <= points)
  2095. X        {
  2096. X            x_pos = two->x;
  2097. X            y_pos = two->y;
  2098. X            h_pos = two->h;
  2099. X            v_pos = two->v;
  2100. X            if (low_val == dist1)
  2101. X            {
  2102. X                two->x = h_pos;
  2103. X                two->y = v_pos;
  2104. X                two->h = x_pos;
  2105. X                two->v = y_pos;
  2106. X                /*
  2107. X                 * now, coordinates are in the correct
  2108. X                 * order...
  2109. X                 */
  2110. X            } else if (low_val == dist3)
  2111. X            {
  2112. X                two->y = v_pos;
  2113. X                two->v = y_pos;
  2114. X            } else if (low_val == dist4)
  2115. X            {
  2116. X                two->x = h_pos;
  2117. X                two->h = x_pos;
  2118. X            }
  2119. X            /* low_val==dist2 is default... */
  2120. X            edit_frame(ff);
  2121. X            if (refr_auto == True)
  2122. X                refresh(pboard, '?', (caddr_t)DUMMY);    /* wipe screen */
  2123. X        }    /* if low_val<=points */
  2124. X        break;
  2125. X
  2126. X
  2127. X
  2128. X    case 'D':    /* which point ? */
  2129. X        four = (struct fig4 *) obj[currIndex];
  2130. X        dist1 = calc_distance(x, y, (int) four->x, (int) four->y);    /* upper left */
  2131. X        dist2 = calc_distance(x, y, (int) four->h, (int) four->v);    /* lower right */
  2132. X        dist3 = calc_distance(x, y, (int) four->h, (int) four->y);    /* upper right */
  2133. X        dist4 = calc_distance(x, y, (int) four->x, (int) four->v);    /* lower left */
  2134. X        if (zoomed == True)
  2135. X        {
  2136. X            dist1 *= 10;
  2137. X            dist2 *= 10;
  2138. X            dist3 *= 10;
  2139. X            dist4 *= 10;
  2140. X        }
  2141. X        /* compute minimum */
  2142. X        if (dist1 < dist2)
  2143. X            low_val = dist1;
  2144. X        else
  2145. X            low_val = dist2;
  2146. X        if (dist3 < low_val)
  2147. X            low_val = dist3;
  2148. X        if (dist4 < low_val)
  2149. X            low_val = dist4;
  2150. X        if (low_val <= points)
  2151. X        {
  2152. X            x_pos = four->x;
  2153. X            y_pos = four->y;
  2154. X            h_pos = four->h;
  2155. X            v_pos = four->v;
  2156. X            if (low_val == dist1)
  2157. X            {
  2158. X                four->x = h_pos;
  2159. X                four->y = v_pos;
  2160. X                four->h = x_pos;
  2161. X                four->v = y_pos;
  2162. X                /*
  2163. X                 * now, coordinates are in the correct
  2164. X                 * order...
  2165. X                 */
  2166. X            } else if (low_val == dist3)
  2167. X            {
  2168. X                four->y = v_pos;
  2169. SHAR_EOF
  2170. true || echo 'restore of pickedit.c failed'
  2171. fi
  2172. echo 'End of  part 7'
  2173. echo 'File pickedit.c is continued in part 8'
  2174. echo 8 > _shar_seq_.tmp
  2175. exit 0
  2176. -- 
  2177. --
  2178. Molecular Simulations, Inc.            mail: dcmartin@msi.com
  2179. 796 N. Pastoria Avenue                uucp: uunet!dcmartin
  2180. Sunnyvale, California 94086            at&t: 408/522-9236
  2181.